Tokenization ve BPE

# BPE (Byte Pair Encoding), en SIK yan yana gelen karakter çiftini bulup
# BİRLEŞTİREREK, karakterlerden yola çıkıp kademeli olarak "alt kelimeler"
# (subword) öğrenen istatistiksel bir yöntemdir. Küçük bir İNGİLİZCE corpus'la
# eğitelim -- gerçek tokenizer'lar (GPT gibi) da İngilizce ağırlıklı veriyle eğitilir.
corpus = """
the quick brown fox jumps over the lazy dog
the dog runs after the fox in the forest
a fox and a dog are running together
the forest is quiet and the trees are tall
she walks through the forest looking for the fox
the lazy dog sleeps under the tall tree
running and jumping are fun activities
the quick fox jumps over another lazy dog
i am learning how computers understand language
computers do not understand words the way people do
they only understand numbers so we convert words into numbers
this process is called tokenization
a tokenizer breaks text into smaller pieces called tokens
some tokenizers split text into words other split into characters
byte pair encoding learns which letters often appear together
it starts with individual characters and merges the most common pairs
after many merges common words become single tokens
rare words stay broken into smaller pieces
this is why understanding tokenization matters for language models
language models like gpt use this kind of tokenizer
the model reads tokens one after another and predicts the next token
training data shapes which words the tokenizer knows well
if a word never appears in training it gets split into many pieces
that is often what happens with words from other languages
turkish words often get split into many more pieces than english words
because turkish adds many suffixes to a single root word
english also has suffixes but fewer than turkish
understanding this helps explain why some languages cost more tokens
more tokens can mean slower and more expensive processing
developers should keep this in mind when building multilingual systems
""".strip().lower()

kelimeler = re.findall(r"[a-z]+", corpus)
kelime_sayaci = Counter(kelimeler)
print(f"Corpus: {len(kelimeler)} kelime, {len(kelime_sayaci)} benzersiz kelime.")

def kelimeyi_hazirla(kelime):
    return list(kelime) + ["</w>"]  # </w>: kelime sonu işareti

sozluk = {tuple(kelimeyi_hazirla(k)): sayi for k, sayi in kelime_sayaci.items()}

def ciftleri_say(sozluk):
    ciftler = Counter()
    for kelime, sayi in sozluk.items():
        for i in range(len(kelime) - 1):
            ciftler[(kelime[i], kelime[i + 1])] += sayi
    return ciftler

def cifti_birlestir(sozluk, cift):
    a, b = cift
    yeni_sozluk = {}
    for kelime, sayi in sozluk.items():
        yeni_kelime, i = [], 0
        while i < len(kelime):
            if i < len(kelime) - 1 and kelime[i] == a and kelime[i + 1] == b:
                yeni_kelime.append(a + b)
                i += 2
            else:
                yeni_kelime.append(kelime[i])
                i += 1
        yeni_sozluk[tuple(yeni_kelime)] = sayi
    return yeni_sozluk

MERGE_SAYISI = 250
birlestirme_kurallari = []
for _ in range(MERGE_SAYISI):
    ciftler = ciftleri_say(sozluk)
    if not ciftler:
        break
    en_sik = ciftler.most_common(1)[0][0]
    birlestirme_kurallari.append(en_sik)
    sozluk = cifti_birlestir(sozluk, en_sik)

print(f"Toplam {len(birlestirme_kurallari)} birleştirme kuralı öğrenildi.")
print("İlk 10 kural (en SIK çiftlerden en NADİRE doğru):")
for i, (a, b) in enumerate(birlestirme_kurallari[:10], 1):
    print(f"  {i}. '{a}' + '{b}' -> '{a}{b}'")

# BPE ile bir kelimeyi kodlamak: öğrenilen kuralları, ÖĞRENİLME SIRASINA göre uygula.
def bpe_encode(kelime, kurallar, iz_tut=False):
    parcalar = kelimeyi_hazirla(kelime)
    izler = [list(parcalar)]
    for a, b in kurallar:
        yeni_parcalar, i = [], 0
        degisti = False
        while i < len(parcalar):
            if i < len(parcalar) - 1 and parcalar[i] == a and parcalar[i + 1] == b:
                yeni_parcalar.append(a + b)
                i += 2
                degisti = True
            else:
                yeni_parcalar.append(parcalar[i])
                i += 1
        parcalar = yeni_parcalar
        if degisti and iz_tut:
            izler.append(list(parcalar))
    return (parcalar, izler) if iz_tut else parcalar

sonuc, izler = bpe_encode("running", birlestirme_kurallari, iz_tut=True)
print(f"\n'running' kelimesinin adım adım birleşimi ({len(izler)} adım):")
for i, adim in enumerate(izler):
    print(f"  adım {i}: {adim}")

# Şimdi bu (İNGİLİZCE ağırlıklı eğitilmiş) tokenizer'ı, hem İngilizce hem
# Türkçe kelimelerde deneyelim.
ingilizce_kelimeler = ["dogs", "forest", "running", "fox", "tokenizer", "language"]
turkce_kelimeler = ["köpekler", "ormanda", "koşuyorlar", "tilkiyi", "kovalıyor", "kelimeler"]

print(f"\n{'İngilizce kelime':<16} {'Token sayısı':<14} {'Parçalar'}")
ingilizce_toplam = 0
for k in ingilizce_kelimeler:
    sonuc = bpe_encode(k, birlestirme_kurallari)
    ingilizce_toplam += len(sonuc)
    print(f"{k:<16} {len(sonuc):<14} {sonuc}")

print(f"\n{'Türkçe kelime':<16} {'Token sayısı':<14} {'Parçalar'}")
turkce_toplam = 0
for k in turkce_kelimeler:
    sonuc = bpe_encode(k, birlestirme_kurallari)
    turkce_toplam += len(sonuc)
    print(f"{k:<16} {len(sonuc):<14} {sonuc}")

ing_ort = ingilizce_toplam / len(ingilizce_kelimeler)
tr_ort = turkce_toplam / len(turkce_kelimeler)
print(f"\nOrtalama token/kelime -- İngilizce: {ing_ort:.2f}, Türkçe: {tr_ort:.2f}")
print(f"Türkçe kelimeler, AYNI tokenizer ile {tr_ort/ing_ort:.1f} KAT daha fazla token'a bölünüyor!")
print("Neden: bu tokenizer İNGİLİZCE ağırlıklı bir corpus'tan öğrendi -- Türkçenin çekim ekleri")
print("(köpek+ler, koş+uyor+lar) hiç görülmediği için, karakterlere yakın parçalanıyor.")
print("Gerçek dünyada da (GPT gibi modellerde) AYNI şey oluyor -- bu, Türkçe kullanıcılar için")
print("hem daha YAVAŞ hem daha PAHALI (token başına ücretlendirme) bir deneyim demek.")