NLP Temelleri: Tokenleştirme, Yerleştirmeler ve Modern İşlem Hattı
Sesli asistandan bir şey istediğinizde, bir metni Google Çeviri ile çevirin, E-posta gelen kutunuzdaki spam'i filtreleyin veya bir videonun otomatik altyazılarını okuyun, kullanıyor musun Doğal Dil İşleme (NLP). Bu disiplin, Dilbilim, bilgisayar bilimi ve yapay zekanın kesiştiği noktada, makinelere insan dilini anlamayı, yorumlamayı ve üretmeyi öğretiyor.
Son yıllarda NLP alanı köklü bir dönüşüme uğradı. yanından geçtik el yazısı kurallar ve statik sözlüklerden nüansları anlayabilen sinir modellerine, bağlam ve hatta ironi. BERT, GPT, LLaMA ve yeni nesil modeller keşfedeceğimiz temel bilgiler olmadan mümkün olmazdı bu makalede: tokenizasyon, gli gömmeler ve Modern NLP boru hattı.
Bu serinin ilk makalesi Modern NLP: BERT'ten Yüksek Lisans'a. Mutlak temellerden başlayacağız, gerekli sezgileri adım adım inşa edeceğiz Daha gelişmiş dil modellerini anlamak için. Özellikle dikkat edeceğiz Anglofon kaynaklarında sıklıkla gözden kaçırılan İtalyan dilinin özelliklerine.
Ne Öğreneceksiniz
- NLP nedir ve neden hemen hemen her modern yapay zeka uygulamasının temelidir?
- Metin nasıl önceden işlenir: küçük harf, engellenen sözcükler, kökten ayırma ve lemmatizasyon
- Belirteçleştirmeye yönelik farklı yaklaşımlar: kelime düzeyinde, karakter düzeyinde ve alt kelime (BPE, WordPiece, SentencePiece)
- Klasik metin gösterimleri: Kelime Çantası ve TF-IDF
- Kelime yerleştirmeler: Word2Vec, GloVe ve anlamın geometrik sezgisi
- Bağlamsal yerleştirmeler: statik temsillerden BERT'e
- Cümle yerleştirmeleri ve pratik uygulamaları
- Modern NLP hattı: ham metinden tahmine
- İtalyanca dili için ön işlemenin özgüllüğü
- Python koduyla eksiksiz bir uçtan uca örnek
Seriye Genel Bakış
| # | Öğe | Odak |
|---|---|---|
| 1 | Buradasınız - NLP'nin Temelleri | Tokenleştirme, Yerleştirmeler, İşlem Hatları |
| 2 | BERT ve Transformatörler | 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. Metin Ön İşleme: Verileri Hazırlayın
Herhangi bir NLP modelinin metinle çalışabilmesi için öncelikle bu temiz ve normalleştirilmiş. Kaba ve gürültülü metin: noktalama işaretleri, büyük harf kullanımı, kısaltmalar, emoji, HTML, URL. Ön işleme bu kaosu bir şeye dönüştürür yapılandırılmış ve tutarlı bir format.
1.1 Küçük Harf ve Normalleştirme
İlk adım tüm metni küçük harfe dönüştürmektir. Bir bilgisayar için "Ev", "ev" ve "HOME" tamamen farklı üç dizedir. Küçük harf onları birleştirir.
import re
import unicodedata
def normalize_text(text: str) -> str:
"""Normalizzazione base del testo."""
# Lowercasing
text = text.lower()
# Rimozione accenti (opzionale, NON consigliato per italiano)
# text = unicodedata.normalize('NFKD', text)
# Rimozione punteggiatura
text = re.sub(r'[^\w\s]', '', text)
# Rimozione spazi multipli
text = re.sub(r'\s+', ' ', text).strip()
return text
testo = "L'NLP e FANTASTICO! Analizza testi in 50+ lingue."
print(normalize_text(testo))
# Output: "lnlp e fantastico analizza testi in 50 lingue"İtalyancadaki aksanlara dikkat edin
İngilizce konuşulan birçok NLP kanalında aksanı kaldırmak standart bir adımdır. İtalyanca, ancak aksanlar kelimelerin anlamını değiştirir: "Ancak" (bağlaç) vs "Ancak" (ağaç), "Ve" (bağlaç) vs "Ve" (olmak fiili). Aksanları asla kaldırma İtalyanca metinle çalışırken.
1.2 Engellenen Kelimeler: Bilgi İçeriği Olmayan Kelimeler
Le engellenecek kelimeler Çok az anlamsal anlam taşıyan, çok sık kullanılan kelimelerdir: makaleler, edatlar, bağlaçlar. Bunları kaldırmak verilerin boyutunu azaltır. modellerin anlamlı kelimelere odaklanmasına yardımcı olur.
İtalyanca ve İngilizce Engellenen Kelimeler
| Dil | Engellenecek Kelime Örnekleri | Tipik Sayım |
|---|---|---|
| İngilizce | bu, şu anda, hangisinde, üzerinde, bir, bir, ve, veya | ~180 kelime |
| İtalyan | the, the, the, of, to, from, in, with, on, for, and, not, a | ~300 kelime |
Makalelerin daha fazla zenginliği nedeniyle İtalyanca'da İngilizce'den daha fazla stopword var (il, lo, la, i, gli, le), eklemli edatlar (del, dello, della, nei, nei, nelle) ve yardımcı fiil biçimleri.
# Approccio 1: NLTK
from nltk.corpus import stopwords
import nltk
nltk.download('stopwords')
stop_it = set(stopwords.words('italian'))
print(f"Stopwords italiane NLTK: {len(stop_it)}")
# Output: Stopwords italiane NLTK: 279
testo = "il gatto mangia il pesce sul tavolo della cucina"
tokens = testo.split()
filtrato = [t for t in tokens if t not in stop_it]
print(filtrato)
# Output: ['gatto', 'mangia', 'pesce', 'tavolo', 'cucina']
# Approccio 2: spaCy (più completo)
import spacy
nlp = spacy.load("it_core_news_lg")
doc = nlp("il gatto mangia il pesce sul tavolo della cucina")
filtrato_spacy = [token.text for token in doc if not token.is_stop]
print(filtrato_spacy)
# Output: ['gatto', 'mangia', 'pesce', 'tavolo', 'cucina']1.3 Köklenme ve Lemmatizasyon
Her iki teknik de kelimeleri temel biçimlerine indirger, ancak bunu çok farklı şekillerde yaparlar.
Köklenme ve Lemmatizasyon - Karşılaştırma
| bekliyorum | Köklenme | Lemmatizasyon |
|---|---|---|
| Yöntem | Buluşsal kurallarla son ekleri kesme | Bir sözlük ve morfolojik analiz kullanın |
| Sonuç | Kök (her zaman gerçek bir kelime değil) | Lemma (sözlükten gerçek kelime) |
| BT örneği | "yemek" -> "yemek yersin" | "yemek" -> "yemek" |
| Hız | Çok hızlı | Daha yavaş (sözlük gerektirir) |
| Kesinlik | Düşük (yaygın aşırı köklenme) | Yüksek (doğru formlar) |
| İtalyanca için | Kartopu Stemmer (İtalyan Hamal) | spaCy it_core_news_lg |
from nltk.stem.snowball import SnowballStemmer
import spacy
# Stemming con Snowball
stemmer = SnowballStemmer("italian")
parole = ["mangiando", "mangiare", "mangiato", "correre", "correndo", "bellissimo"]
stems = [stemmer.stem(p) for p in parole]
print(dict(zip(parole, stems)))
# {'mangiando': 'mang', 'mangiare': 'mang', 'mangiato': 'mang',
# 'correre': 'corr', 'correndo': 'corr', 'bellissimo': 'bellissim'}
# Lemmatization con spaCy
nlp = spacy.load("it_core_news_lg")
doc = nlp("Le ragazze stavano mangiando le mele più belle")
lemmi = [(token.text, token.lemma_, token.pos_) for token in doc]
for testo, lemma, pos in lemmi:
print(f" {testo:15s} -> {lemma:15s} ({pos})")
# le -> il (DET)
# ragazze -> ragazza (NOUN)
# stavano -> stare (AUX)
# mangiando -> mangiare (VERB)
# le -> il (DET)
# mele -> mela (NOUN)
# più -> più (ADV)
# belle -> bello (ADJ)
İtalyanca için, spaCy ile lemmatizasyon ve neredeyse her zaman tercih edilir
kök salmaya. Model it_core_news_lg 500.000 kelime vektörü içerir
ve tokenizasyon, POS etiketleme, bağımlılık ayrıştırma, NER ve lemmatizasyon'u destekler.
2. Tokenizasyon: Makineler Metni Nasıl Okur?
La tokenizasyon ve metni ayrı birimlere bölme işlemi aramalar jeton. Ve herhangi bir NLP hattının ilk ve en kritik adımı: Tokenizasyonun kalitesi sonraki her modelin performansını doğrudan etkiler.
Her birinin farklı yararları ve değiş tokuşları olan üç temel yaklaşım vardır.
2.1 Kelime Düzeyinde Belirleme
En sezgisel yaklaşım: Her kelime bir simgeye dönüşür.
# Approccio naive: split per spazio
testo = "L'intelligenza artificiale cambia il mondo"
tokens_naive = testo.split()
print(tokens_naive)
# ["L'intelligenza", 'artificiale', 'cambia', 'il', 'mondo']
# Problema: "L'intelligenza" e un singolo token!
# Approccio migliore: spaCy
import spacy
nlp = spacy.load("it_core_news_lg")
doc = nlp(testo)
tokens_spacy = [token.text for token in doc]
print(tokens_spacy)
# ["L'", 'intelligenza', 'artificiale', 'cambia', 'il', 'mondo']
# spaCy gestisce correttamente le elisioni italianeKelime Düzeyinde Simgeleştirmenin Sınırları
- Büyük kelime dağarcığı: Her benzersiz kelime bir kelime girişi gerektirir. İtalyancada yüzbinlerce çekimli biçim vardır
- Kelime dağarcığı dışında kalan kelimeler (OOV): Eğitim sırasında hiç görülmeyen kelimeler <UNK> (bilinmiyor) olur
- Morfolojik paylaşım yok: "yemek", "yemek", "yemek" tamamen ayrı, ilgisiz üç simgedir
2.2 Karakter Düzeyinde Belirleme
Diğer uçta ise her karakter bir simge haline gelir. Kelime dağarcığı çok küçük (26 harf + rakam + noktalama işareti), ancak diziler çok uzun oluyor.
Testo: "ciao mondo"
Word-level: ["ciao", "mondo"] -> 2 token
Char-level: ["c","i","a","o"," ","m","o","n","d","o"] -> 10 token
Testo di 1000 parole:
Word-level: ~1.000 token
Char-level: ~5.000 token (5x più lungo!)
Karakter tokenizasyonu, bilinmeyen kelimeler sorununu çözer (herhangi bir kelime temsil edilebilir), ancak çok uzun diziler modeller için işi zorlaştırır metindeki uzun vadeli ilişkileri yakalayın.
2.3 Alt Kelime Belirleme: Optimal Uzlaşma
La alt kelime tokenizasyonu ve tüm modern modellerin kullandığı yöntem (BERT, GPT, LLaMA, T5). Fikir harika: Ortak kelimeler bütün olarak kalırken kelimeler nadir, modelin daha önce gördüğü alt birimlere (alt kelimelere) bölünür.
Alt Kelime Belirleme Algoritmaları
| Algoritma | Kullanan | Strateji | Yön |
|---|---|---|---|
| BPE (Bayt Çifti Kodlaması) | GPT-2, GPT-3, GPT-4, LLaMA, RoBERTa | En sık görülen çiftlerin yinelemeli birleştirilmesi | Altüst |
| Kelime Parçası | BERT, DistilBERT, ELECTRA | Olasılığı en üst düzeye çıkaran birleştirme | Altüst |
| CümleParçası | T5, ALBERT, XLNet, mBART | Metni ham bir karakter akışı olarak ele alın | Dilden bağımsız |
| Unigram | Cümle Parçası (isteğe bağlı), ALBERT | Geniş kelime dağarcığından başlar, daha az kullanışlı belirteçleri kaldırır | Yukarıdan aşağıya |
BPE (Bayt Çifti Kodlama) nasıl çalışır?
BPE tek karakterden başlar ve en sık görülen çiftleri yinelemeli olarak birleştirir İstediğiniz kelime büyüklüğüne ulaşana kadar.
Corpus: "basso basso bassa basso"
Passo 0 - Vocabolario iniziale (caratteri):
b, a, s, o
Passo 1 - Coppia più frequente: (s, s) -> "ss"
b a ss o b a ss o b a ss a b a ss o
Passo 2 - Coppia più frequente: (a, ss) -> "ass"
b ass o b ass o b ass a b ass o
Passo 3 - Coppia più frequente: (b, ass) -> "bass"
bass o bass o bass a bass o
Passo 4 - Coppia più frequente: (bass, o) -> "basso"
basso basso bass a basso
Vocabolario finale: [b, a, s, o, ss, ass, bass, basso]
WordPiece vs BPE
WordPiece, BPE'ye benzer bir yaklaşım kullanır ancak artı çiftini seçmek yerine
sıkmaksimuma çıkaranı seçin olasılık külliyatın
eğitim. Uygulamada, WordPiece daha kullanışlı belirteçler üreten birleştirmeleri tercih eder
dil modeli için, yalnızca en yaygın olanları değil. Başlamayan jetonlar
bir kelimenin önüne bir kelime eklenir ##.
Cümle Parçası: Dil Bağımsızlığı
SentencePiece'ın temel farkı şudur: ön tokenizasyon gerektirmez. BPE ve WordPiece, metnin zaten sözcüklere (genellikle boşlukla) bölündüğünü varsayar; İngilizce ve İtalyanca için iyi çalışıyor ancak Çince, Japonca veya Tayca gibi diller için başarısız oluyor kelimeler arasında boşluk kullanmazlar. SentencePiece metni ham bir bayt akışı olarak ele alır, onu gerçekten dilden bağımsız hale getiriyor.
3. Pratik Örnek: HuggingFace ile Tokenizasyon
BERT ve GPT-2'nin aynı İtalyanca metni nasıl simgeleştirdiğini somut olarak görelim.
Kütüphaneyi kullanacağız transformers HuggingFace tarafından.
from transformers import AutoTokenizer
# Testo di esempio in italiano
testo = "L'intelligenza artificiale sta rivoluzionando il mondo"
# --- BERT (WordPiece) ---
bert_tok = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")
bert_tokens = bert_tok.tokenize(testo)
bert_ids = bert_tok.encode(testo)
print("BERT tokens:", bert_tokens)
print("BERT IDs: ", bert_ids)
# BERT tokens: ['L', "'", 'intelligenza', 'artificiale', 'sta',
# 'rivoluzionando', 'il', 'mondo']
# BERT IDs: [102, 55, 7, 5765, 6892, 379, 28648, 42, 1601, 103]
# --- GPT-2 (BPE) ---
gpt2_tok = AutoTokenizer.from_pretrained("gpt2")
gpt2_tokens = gpt2_tok.tokenize(testo)
gpt2_ids = gpt2_tok.encode(testo)
print("\nGPT-2 tokens:", gpt2_tokens)
print("GPT-2 IDs: ", gpt2_ids)
# GPT-2 tokens: ['L', "'", 'int', 'ell', 'ig', 'enza', ' art',
# 'ific', 'iale', ' sta', ' riv', 'oluz', 'ion',
# 'ando', ' il', ' mondo']
# --- Confronto ---
print(f"\nBERT: {len(bert_tokens)} token")
print(f"GPT-2: {len(gpt2_tokens)} token")Temel Gözlemler
- BERT İtalyanca (
dbmdz/bert-base-italian-cased) "zeka" ve "rivoluzionando" kelimelerini tamsayı belirteçleri olarak tanır, çünkü kelime dağarcığı İtalyanca metinlere göre eğitilmiştir - GPT-2 İtalyanca kelimeleri çok daha fazla alt kelimeye böler, çünkü kelime dağarcığı esas olarak İngilizce metinler üzerine eğitilmiştir
- Hedef dilde eğitilmiş bir tokenizer daha az token üretir, bu da şu anlama gelir: dikkat penceresinde daha fazla bağlam e jeton başına daha düşük maliyetler
- BERT özel jetonlar ekler:
[CLS]başlangıçta ve[SEP]Sonunda. GPT-2 çalışmıyor
from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")
# Dimensione vocabolario
print(f"Vocabolario BERT italiano: {tok.vocab_size} token")
# Output: Vocabolario BERT italiano: 31102 token
# Token speciali
print(f"[CLS] = {tok.cls_token} (ID: {tok.cls_token_id})")
print(f"[SEP] = {tok.sep_token} (ID: {tok.sep_token_id})")
print(f"[PAD] = {tok.pad_token} (ID: {tok.pad_token_id})")
print(f"[UNK] = {tok.unk_token} (ID: {tok.unk_token_id})")
print(f"[MASK] = {tok.mask_token} (ID: {tok.mask_token_id})")
# Decodifica: da token IDs -> testo
ids = tok.encode("NLP e fantastico")
print(f"\nEncode: {ids}")
print(f"Decode: {tok.decode(ids)}")
# Decode: [CLS] NLP e fantastico [SEP]4. Kelime Torbası ve TF-IDF: Klasik Temsiller
Kelime yerleştirmeden önce metin şu şekilde temsil ediliyordu: seyrek vektörler Kelime sıklığına göre. Bu yöntemler hala birçok bağlamda kullanılmaktadır ve sınırlamalarını anlamak, yerleştirmelerin neden bir devrim olduğunu anlamanıza yardımcı olur.
4.1 Kelime Torbası (BoW)
Model Kelime Torbası bir belgeyi vektör olarak temsil eder; her pozisyon bir kelime kelimesine ve değeri ve sayısına karşılık gelir. bu kelimenin belgede geçtiği yerler.
from sklearn.feature_extraction.text import CountVectorizer
documenti = [
"il gatto mangia il pesce",
"il cane mangia la carne",
"il gatto insegue il cane"
]
vectorizer = CountVectorizer()
bow_matrix = vectorizer.fit_transform(documenti)
print("Vocabolario:", vectorizer.get_feature_names_out())
# ['cane', 'carne', 'gatto', 'il', 'insegue', 'la', 'mangia', 'pesce']
print("\nMatrice BoW:")
print(bow_matrix.toarray())
# [[0, 0, 1, 2, 0, 0, 1, 1], # doc 1
# [1, 1, 0, 1, 0, 1, 1, 0], # doc 2
# [1, 0, 1, 2, 1, 0, 0, 0]] # doc 34.2 TF-IDF (Dönem Frekansı – Ters Belge Frekansı)
TF-IDF, sözcükleri kendilerine göre ağırlıklandırarak BoW'u geliştiriyor göreceli önem. Bir belgede sık karşılaşılan ancak genel metinde nadir bulunan sözcüklere daha fazla ağırlık verilir. Her yerde yaygın olarak kullanılan kelimeler ("the", "the" gibi) düşük ağırlık alır.
TF-IDF(t, d) = TF(t, d) x IDF(t)
dove:
TF(t, d) = frequenza del termine t nel documento d
IDF(t) = log(N / df(t))
N = numero totale di documenti
df(t) = numero di documenti che contengono il termine t
Esempio:
Parola "gatto" in documento 1:
TF = 1/5 = 0.2 (1 occorrenza su 5 parole)
IDF = log(3/2) = 0.405 (appare in 2 documenti su 3)
TF-IDF = 0.2 x 0.405 = 0.081
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np
documenti = [
"il gatto mangia il pesce",
"il cane mangia la carne",
"il gatto insegue il cane"
]
tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(documenti)
print("Feature:", tfidf.get_feature_names_out())
print("\nMatrice TF-IDF (arrotondata):")
print(np.round(tfidf_matrix.toarray(), 3))
# "pesce" e "carne" hanno pesi più alti perchè appaiono
# in un solo documento (più discriminanti)BoW ve TF-IDF Limitleri
- Anlambilim yok: "köpek" ve "köpek" tamamen farklıdır; "Banka" (nehir) ve "banka" (kurum) aynıdır
- Sipariş yok: "kedi fareyi yer" ve "fare kediyi yer" aynı temsile sahiptir
- Yüksek boyutluluk: 100.000 kelimelik bir kelime dağarcığı, neredeyse tamamı sıfır olan 100.000 boyutlu vektörler üretir (seyrek vektörler)
- Genelleme yok: Kelimeler arasındaki ilişkileri yakalayamazlar ("kral" ve "kraliçe"nin yakınlığı yoktur)
5. Kelime Gömmeleri: Geometri Olarak Anlam
I kelime yerleştirmeleri kelimeleri dönüştürerek NLP'de devrim yarattılar yakalayan yoğun düşük boyutlu vektörlerde (tipik olarak 100-300 boyut) Kelimeler arasındaki anlamsal ilişkiler. Benzer anlama sahip iki kelime olacak vektörler komşular vektör uzayında.
5.1 Word2Vec: Her Şeyi Değiştiren Buluş
Tomas Mikolov ve meslektaşları tarafından tanıtılan (Google, 2013), Word2Eski Kelimelerin vektörlerini, göründükleri bağlamdan başlayarak öğrenir. Sezgi temel ve dağıtım hipotezi: "bir kelime şu şekilde karakterize edilir: tuttuğu şirket" (J.R. Firth, 1957).
İki Word2Vec Mimarisi
| Mimarlık | Giriş | Çıkışlar | Sezgi |
|---|---|---|---|
| CBOW (Sürekli Kelime Torbası) | Bağlam (çevreleyen kelimeler) | Hedef kelime | "___ yiyor" bağlamı göz önüne alındığında, "kedi"yi tahmin edin |
| Gram atla | Hedef kelime | Bağlam (çevreleyen kelimeler) | "Kedi" kelimesi verildiğinde "o", "yemek" vb. tahmin edin. |
Pratikte, Gram atla küçük veri kümeleri ve yakalamalarla en iyi şekilde çalışır nadir kelimeler daha iyidir. CBOW daha hızlıdır ve sık kullanılan kelimelerle iyi çalışır.
Frase: "il gatto nero mangia il pesce fresco"
^
parola target
Con window_size = 2, Skip-gram impara:
gatto -> il (contesto a sinistra, distanza 1)
gatto -> nero (contesto a destra, distanza 1)
gatto -> mangia (contesto a destra, distanza 2)
Dopo milioni di frasi, parole che appaiono in contesti
simili avranno vettori simili:
gatto ~ felino ~ micio (contesti simili: "il ___ mangia")
cane ~ canino ~ cucciolo (contesti simili: "il ___ corre")
5.2 Kelimelerin Aritmetiği
Kelime yerleştirmelerin en şaşırtıcı özelliği, anlamsal ilişkiler cebirsel işlemler haline gelirler taşıyıcılar üzerinde. Ünlü benzetme:
kral - erkek + kadın = kraliçe
Tesadüf değil: "Erkek"ten "kadına" giden vektör, "erkek"ten "kadına" giden vektörle aynı "kral"dan "kraliçe"ye. Bu birçok ilişki için işe yarar: ülke-büyük harf, fiil-geçmiş zaman, üstün sıfat.
import gensim.downloader as api
# Carica word embeddings pre-addestrati
model = api.load("word2vec-google-news-300")
# Analogia: re - uomo + donna = ?
result = model.most_similar(
positive=["king", "woman"],
negative=["man"],
topn=3
)
print("king - man + woman =")
for word, score in result:
print(f" {word}: {score:.4f}")
# king - man + woman =
# queen: 0.7118
# monarch: 0.6189
# princess: 0.5902
# Similarità tra parole
print(f"\ncat ~ dog: {model.similarity('cat', 'dog'):.4f}")
print(f"cat ~ car: {model.similarity('cat', 'car'):.4f}")
# cat ~ dog: 0.7609
# cat ~ car: 0.20045.3 GloVe: Kelime Temsili için Küresel Vektörler
Eldiven (Stanford, 2014) farklı bir yaklaşım benimsiyor: tahmin etmek yerine GloVe, Word2Vec gibi kelime kelime bağlamla bir ilki gerçekleştiriyor küresel birlikte oluşum matrisi tüm derlemin tamamını çarpanlara ayırın vektörleri elde etmek için bu matris. dayalı yöntemlerin avantajlarını birleştirir. Word2Vec yerel öğrenmeninkilerle küresel istatistikler.
Word2Vec ve GloVe
| bekliyorum | Word2Eski | Eldiven |
|---|---|---|
| Yöntem | Tahmine dayalı (sinir ağı) | Sayıya dayalı (matris çarpanlarına ayırma) |
| Bağlam | Yerel pencere | Küresel derlem istatistikleri |
| Eğitim | Çevrimiçi (metin kaydırmaları) | Toplu iş (tam dizi) |
| Ortak boyutlar | 100, 200, 300 | 50, 100, 200, 300 |
| Performans | Analojiler için mükemmel | Benzerlik açısından mükemmel |
6. Bağlamsal Yerleştirmeler: Aynı Kelime, Farklı Anlamlar
Word2Vec ve GloVe'nin temel bir sınırlaması vardır: tek bir vektör her kelimeylebağlamdan bağımsız olarak. Ama dil dolu belirsizlik: "banka" kelimesinin tamamen farklı bir anlamı vardır "okul masası" ve "Napoli masası".
Gli bağlamsal yerleştirmeler bu sorunu çöz: vektör Bir kelimenin anlamı, içinde geçtiği cümlenin tamamına bağlıdır. Bu, tarafından kullanılan yaklaşımdır BERT, GPT ve tüm Transformer tabanlı modeller.
Statik ve Bağlamsal Gömmeler
| bekliyorum | Statik (Word2Vec, GloVe) | Bağlamsal (BERT, GPT) |
|---|---|---|
| Kelime için vektör | Sabit bir şey, her zaman aynı | Bağlama göre farklı |
| Çok anlamlılık | Yönetilmeyen ("bankanın" yalnızca bir taşıyıcısı vardır) | Yönetilen ("anlaşma"nın her anlam için farklı vektörleri vardır) |
| Modeli | Arama tablosu | Derin Sinir Ağı (Transformatör) |
| Modeli boyutu | Birkaç MB | Yüzlerce MB veya GB |
| Hız | Ani | İleri geçiş gerektirir |
from transformers import AutoTokenizer, AutoModel
import torch
import torch.nn.functional as F
# Carica BERT italiano
tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-italian-cased")
model = AutoModel.from_pretrained("dbmdz/bert-base-italian-cased")
def get_word_embedding(sentence: str, word: str):
"""Ottieni l'embedding contestuale di una parola nella frase."""
inputs = tokenizer(sentence, return_tensors="pt")
tokens = tokenizer.tokenize(sentence)
with torch.no_grad():
outputs = model(**inputs)
# outputs.last_hidden_state: [batch, seq_len, hidden_dim]
embeddings = outputs.last_hidden_state[0] # [seq_len, 768]
# Trova l'indice del token target
word_idx = tokens.index(word) + 1 # +1 per [CLS]
return embeddings[word_idx]
# "banco" in contesti diversi
emb_scuola = get_word_embedding("Il banco di scuola e rotto", "banco")
emb_banca = get_word_embedding("Il banco di Napoli e storico", "banco")
emb_pesce = get_word_embedding("Il banco del pesce e fresco", "banco")
# Calcola similarità coseno
sim_12 = F.cosine_similarity(emb_scuola.unsqueeze(0), emb_banca.unsqueeze(0))
sim_13 = F.cosine_similarity(emb_scuola.unsqueeze(0), emb_pesce.unsqueeze(0))
sim_23 = F.cosine_similarity(emb_banca.unsqueeze(0), emb_pesce.unsqueeze(0))
print(f"banco(scuola) ~ banco(banca): {sim_12.item():.4f}")
print(f"banco(scuola) ~ banco(pesce): {sim_13.item():.4f}")
print(f"banco(banca) ~ banco(pesce): {sim_23.item():.4f}")
# I vettori saranno DIVERSI perchè BERT capisce il contesto!Bu temel kavramsal sıçramadır: BERT ile "banka" kelimesi artık mevcut değildir sabit bir anlam. Vektörü çevreye göre değişir, tıpkı insanın dili anlamasında gerçekleşir.
7. Cümle Yerleştirmeleri: Tüm Cümle İçin Tek Bir Vektör
Çoğu zaman tek bir kelimenin yerleştirilmesine değil,cümlenin tamamı veya paragraf. THE cümle yerleştirmeleri anlamı sıkıştırıyorlar Tek bir sabit boyutlu vektörde herhangi bir uzunluktaki metin.
Referans modeli e Cümle-BERT (SBERT), bu değişir
Karşılaştırma için optimize edilmiş cümle yerleştirmeleri üretmek için BERT mimarisi
benzerlik. İtalyan için model paraphrase-multilingual-MiniLM-L12-v2
384 boyutlu vektörlerle 50'den fazla dili destekler.
Cümle Yerleştirme Uygulamaları
| Başvuru | Tanım | Nasıl Çalışır? |
|---|---|---|
| Semantik Arama | Anahtar kelimeye göre değil, anlama göre arama yapın | Sorguyu ekleyin, en yakın belgeleri arayın |
| Kümeleme | Benzer metinleri otomatik olarak gruplandırın | Yerleştirmelerde K-araçları veya HDBSCAN |
| Yinelenen Algılama | Yinelenenleri veya neredeyse kopyaları bulma | Kosinüs benzerliği eşiği > 0,9 |
| Sıfır Atış sınıflandırması | Eğitim verileri olmadan sıralama | Metin yerleştirmeyi etiket yerleştirmeyle karşılaştırın |
from sentence_transformers import SentenceTransformer, util
# Modello multilingue (supporta italiano)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2")
# Frasi in italiano
frasi = [
"Il gatto dorme sul divano",
"Il felino riposa sul sofa",
"La borsa e salita oggi",
"I mercati finanziari sono in crescita",
"Ho comprato un nuovo computer portatile"
]
# Genera embeddings (1 vettore per frase, 384 dimensioni)
embeddings = model.encode(frasi, convert_to_tensor=True)
print(f"Shape: {embeddings.shape}") # [5, 384]
# Calcola matrice di similarità
cosine_scores = util.cos_sim(embeddings, embeddings)
print("\nMatrice di Similarità:")
for i in range(len(frasi)):
for j in range(i + 1, len(frasi)):
print(f" {frasi[i][:40]:40s} <-> {frasi[j][:40]:40s}")
print(f" Similarità: {cosine_scores[i][j]:.4f}")
# Risultati attesi:
# "gatto dorme" <-> "felino riposa" : ~0.85 (molto simili)
# "borsa salita" <-> "mercati crescita": ~0.70 (correlati)
# "gatto dorme" <-> "borsa salita" : ~0.10 (non correlati)8. Modern NLP Boru Hattı
Bireysel bileşenleri gördük. Şimdi nasıl çalıştığını anlamak için bunları bir araya getirelim bir Modern uçtan uca NLP hattıBERT, GPT ve tarafından kullanılan Transformer'ı temel alan tüm modeller.
Testo Grezzo
|
v
[1. TOKENIZZAZIONE]
Input: "L'intelligenza artificiale e fantastica"
Output: ["L'", "intelligenza", "artificiale", "e", "fantastica"]
|
v
[2. ENCODING (Token -> ID)]
Input: ["L'", "intelligenza", "artificiale", "e", "fantastica"]
Output: [102, 55, 5765, 6892, 15, 23456, 103]
^[CLS] ^[SEP]
|
v
[3. EMBEDDING LAYER]
Input: [102, 55, 5765, 6892, 15, 23456, 103]
Output: Matrice [7 x 768] - un vettore 768-dim per ogni token
|
v
[4. TRANSFORMER ENCODER/DECODER]
Self-Attention: ogni token "guarda" tutti gli altri
Input: Matrice [7 x 768]
Output: Matrice [7 x 768] (vettori contestualizzati)
|
v
[5. TASK HEAD]
Classificazione: [CLS] embedding -> softmax -> classe
NER: ogni token -> etichetta entità
Generazione: ultimo token -> prossimo token
QA: posizione inizio/fine risposta
Tokenın Rolü [CLS]
BERT'te özel token [CLS] Her girişin başına eklenir.
Transformatörün tüm katmanlarından geçtikten sonra, onun gömülmesi şunu temsil eder:
tüm dizi. Ve sınıflandırma görevleri için girdi olarak kullanılır
(duygu analizi, spam tespiti vb.).
9. İtalyanca için NLP: Özellikler ve Araçlar
İtalyanca dili, NLP'yi İngilizce'den ayıran benzersiz zorluklar sunuyor ve diğer dillerden. Bu özelliklerin bilinmesi sistem oluşturma açısından önemlidir İtalyanca için etkili NLP.
9.1 İtalyancanın Dilsel Zorlukları
NLP için İtalyancanın özel özellikleri
| Meydan okumak | Tanım | Örnek |
|---|---|---|
| Zengin morfoloji | Her fiilin düzinelerce eşlenik formu vardır | "ye"nin 50'den fazla biçimi vardır (yerim, yerim, yerim, yeriz...) |
| Seçimler ve kesme işaretleri | Makaleler ve edatlar birleşiyor | "adam", "sanatın adamı", "arkadaş", "bu yıl" |
| Eklemli edatlar | Edat + makale tek kelimeyle | "del" (di+il), "nello" (in+lo), "sulla" (su+la) |
| Önemli vurgular | Anlamını değiştiriyorlar | "e" (ve) vs "e" (is), "da" (from) vs "da" (verir) |
| Klitik zamirler | Fiile sadık kalıyorlar | "onu bana ver" (ver+me+it), "onu ona getir" |
| Ücretsiz sipariş | SVO zorunlu değildir | "Marco pastayı yiyor" = "Marco pastayı yiyor" |
9.2 İtalyanca için önceden eğitilmiş modeller
Başlıca İtalyan Modelleri
| Modeli | Temel | Görevler | Depolar |
|---|---|---|---|
| dbmdz/bert-base-italyan kasalı | BERT | Genel amaçlı İtalyan NLP'si | SarılmaYüz |
| Alberto | BERT | İtalyan sosyal medyası (Twitter) | SarılmaYüz |
| italyanca-duygusunu hisset | UBERTo | İtalyan duygu analizi | MilaNLProc |
| İtalyan-duygusunu hisset | UBERTo | Duygu tespiti (sevinç, öfke, korku, üzüntü) | MilaNLProc |
| İtalyan-Yasal-BERT | BERT | İtalyanca hukuki metinler | Dlicari |
| DeepMount00/Italian_NER_XXL | BERT | İtalyan İsimli Kuruluşun Tanınması | SarılmaYüz |
| it_core_news_lg | spaCy CNN | Tokenleştirme, POS, NER, lemma, ayrıştırma | uzay |
9.3 İtalyancaya Özel Ön İşleme
import spacy
import re
class ItalianPreprocessor:
"""Pipeline di preprocessing specifica per l'italiano."""
def __init__(self):
self.nlp = spacy.load("it_core_news_lg")
# Stopwords aggiuntive regionali/informali
self.custom_stops = {
"cioe", "quindi", "comunque", "praticamente",
"allora", "insomma", "magari", "ecco", "tipo",
"boh", "mah", "vabbe", "ok", "okay"
}
def preprocess(self, text: str, remove_stops: bool = True,
lemmatize: bool = True) -> list[str]:
"""Preprocessing completo per testo italiano."""
# 1. Normalizzazione base
text = text.lower()
text = re.sub(r'http\S+|www\.\S+', '', text) # rimuovi URL
text = re.sub(r'[^\w\s\']', '', text) # mantieni apostrofi
text = re.sub(r'\d+', '', text) # rimuovi numeri
text = re.sub(r'\s+', ' ', text).strip()
# 2. Analisi con spaCy
doc = self.nlp(text)
# 3. Filtraggio e lemmatizzazione
tokens = []
for token in doc:
# Salta punteggiatura e spazi
if token.is_punct or token.is_space:
continue
# Salta stopwords se richiesto
if remove_stops and (token.is_stop or
token.text in self.custom_stops):
continue
# Lemmatizza o usa la forma originale
word = token.lemma_ if lemmatize else token.text
if len(word) > 1: # salta caratteri singoli
tokens.append(word)
return tokens
# Esempio d'uso
prep = ItalianPreprocessor()
testo = """L'intelligenza artificiale sta rivoluzionando
il modo in cui le aziende italiane gestiscono i loro
processi, cioe praticamente tutto sta cambiando."""
risultato = prep.preprocess(testo)
print("Token processati:", risultato)
# ['intelligenza', 'artificiale', 'rivoluzionare', 'modo',
# 'azienda', 'italiano', 'gestire', 'processo', 'cambiare']10. Uçtan Uca Örnek: İtalyancada Semantik Arama
Öğrendiğimiz her şeyi tek bir örnekte toplayalım: anlamsal arama İtalyanca metinlerden oluşan bir külliyat üzerinde. Bir set verildi belge sayısı ve bir kullanıcı sorgusu kullanarak en alakalı belgeleri bulacağız. cümle yerleştirmeleri.
from sentence_transformers import SentenceTransformer, util
import torch
class SemanticSearchIT:
"""Motore di ricerca semantica per testi italiani."""
def __init__(self, model_name: str =
"paraphrase-multilingual-MiniLM-L12-v2"):
self.model = SentenceTransformer(model_name)
self.documents: list[str] = []
self.embeddings = None
def index_documents(self, documents: list[str]) -> None:
"""Indicizza i documenti calcolando gli embeddings."""
self.documents = documents
self.embeddings = self.model.encode(
documents,
convert_to_tensor=True,
show_progress_bar=True
)
print(f"Indicizzati {len(documents)} documenti")
print(f"Shape embeddings: {self.embeddings.shape}")
def search(self, query: str, top_k: int = 3) -> list[dict]:
"""Cerca i documenti più rilevanti per la query."""
query_embedding = self.model.encode(
query, convert_to_tensor=True
)
scores = util.cos_sim(query_embedding, self.embeddings)[0]
top_results = torch.topk(scores, k=min(top_k, len(self.documents)))
results = []
for score, idx in zip(top_results.values, top_results.indices):
results.append({
"documento": self.documents[idx],
"score": round(score.item(), 4),
"indice": idx.item()
})
return results
# --- Esempio d'uso ---
corpus = [
"Python e un linguaggio di programmazione versatile e facile da imparare",
"Il machine learning permette ai computer di imparare dai dati",
"Angular e un framework per costruire applicazioni web moderne",
"La pasta alla carbonara e un piatto tipico della cucina romana",
"I database relazionali usano SQL per interrogare i dati",
"Il deep learning utilizza reti neurali con molti strati nascosti",
"Roma e la capitale d'Italia e ha una storia millenaria",
"Le API REST permettono la comunicazione tra servizi web",
"Il Natural Language Processing analizza e comprende il testo",
"La pizza napoletana e patrimonio UNESCO dal 2017"
]
# Crea il motore di ricerca e indicizza
search_engine = SemanticSearchIT()
search_engine.index_documents(corpus)
# Esegui alcune ricerche
queries = [
"come analizzare il linguaggio naturale",
"framework per sviluppo frontend",
"cucina tradizionale italiana"
]
for query in queries:
print(f"\nQuery: '{query}'")
print("-" * 60)
results = search_engine.search(query, top_k=3)
for i, r in enumerate(results, 1):
print(f" {i}. [{r['score']:.4f}] {r['documento']}")Beklenen Sonuçlar
Semantik arama şunları içerir: Anlamsadece kelimeler değil. Örneğin:
- "doğal dil nasıl analiz edilir" tam olarak bu kelimeleri içermese bile NLP belgesini bulacaktır
- "Ön uç geliştirme çerçevesi" belgede "ön uç" görünmese bile Angular'ı bulur (ancak "modern web uygulamaları" anlamsal olarak ilişkilidir)
- "geleneksel İtalyan mutfağı" hem carbonara hem de pizzayı bulacaksınız çünkü model anlamsal ilişkiyi anlıyor
Yol Haritası: Buradan Yüksek Lisans'a
Bu yazıda modern NLP'nin temellerini şu adımlardan başlayarak inşa ettik: Bağlamsal yerleştirmelere kadar metin ön işleme ve tüm işlem hattı. İzlediğimiz yolu özetleyelim:
Kavramların Özeti
| Konsept | O ne yapar | Evrim |
|---|---|---|
| Ön işleme | Ham metni temizler ve normalleştirir | Manuel kurallar -> spaCy boru hattı |
| Tokenizasyon | Metni ayrı birimlere böler | Kelime -> Karakter -> Alt Kelime (BPE/WordPiece) |
| BoW/TF-IDF | Metni seyrek vektörler olarak temsil eder | Basit ama anlambilimsiz |
| Kelime Gömmeleri | Anlamı yakalayan yoğun vektörler | Word2Vec -> GloVe -> FastText |
| Bağlamsal Gömmeler | Bağlama bağlı vektörler | ELMo -> BERT -> GPT |
| Cümle Gömmeleri | Tüm cümle için bir vektör | Medya havuzu -> Cümle-BERT |
içinde sonraki makale mimariye geçiş yapacağız her şeyde devrim yarattı: Transformatörler. Mekanizmayı detaylı olarak göreceğiz arasında Kişisel DikkatBERT'in neden oyunun kurallarını değiştirdiğini anlayacağız ve öğreneceğiz Bunu metin sınıflandırma ve soru yanıtlama gibi gerçek görevler için kullanmak için.
Daha fazla bilgi edinmek için kaynaklar
- spaCy İtalyan Modelleri: spaCy İtalyan modelleri için resmi belgeler (spacy.io/models/it)
- Sarılma Yüz Modelleri: Önceden eğitilmiş İtalyan modellerinin deposu (huggingface.co/models?language=it)
- Cümle-BERT: cümle dönüştürücüler belgeleri (sbert.net)
- HİSSET: İtalyanca için duygu analizi ve duygu sınıflandırması (MilaNLProc)
- Kağıt Word2Vec: "Vektör Uzayında Kelime Temsillerinin Etkin Tahmini" (Mikolov ve diğerleri, 2013)
- Kağıt Eldiven: “Kelime Temsili için Küresel Vektörler” (Pennington ve diğerleri, 2014)
- Kağıt BERT: “BERT: Derin Çift Yönlü Transformatörlerin Ön Eğitimi” (Devlin ve diğerleri, 2019)