Word embedding (Word2Vec, GloVe)

# 4. dersin sonundaki hedefi hatırla: kelimeleri, anlamca yakın olanların yakın
# olduğu yoğun vektörlere çevirmek. Bunun için önce (şablonlarla, doğru Türkçe
# ünlü uyumu kurallarıyla) küçük ama semantik yapısı olan bir corpus üretelim.
UNLU_KALIN_DUZ, UNLU_KALIN_YUVARLAK = set("aı"), set("ou")
UNLU_INCE_DUZ, UNLU_INCE_YUVARLAK = set("ei"), set("öü")
TUM_UNLULER = UNLU_KALIN_DUZ | UNLU_KALIN_YUVARLAK | UNLU_INCE_DUZ | UNLU_INCE_YUVARLAK
SERT_UNSUZLER = set("çfhkpsşt")

def son_unlu(kelime):
    for h in reversed(kelime):
        if h in TUM_UNLULER:
            return h
    return "a"

def lokatif_ek(kelime):
    h = son_unlu(kelime)
    ek = "de" if h in (UNLU_INCE_DUZ | UNLU_INCE_YUVARLAK) else "da"
    return kelime + ("t" + ek[1:] if kelime[-1] in SERT_UNSUZLER else ek)

def yonelme_ek(kelime):
    h = son_unlu(kelime)
    ek = "e" if h in (UNLU_INCE_DUZ | UNLU_INCE_YUVARLAK) else "a"
    return kelime + (("y" + ek) if kelime[-1] in TUM_UNLULER else ek)

def dir_ek(kelime):
    h = son_unlu(kelime)
    ek = {"a": "dır", "ı": "dır", "o": "dur", "u": "dur", "e": "dir", "i": "dir", "ö": "dür", "ü": "dür"}[h]
    return kelime + ("t" + ek[1:] if kelime[-1] in SERT_UNSUZLER else ek)

ROYAL_M, ROYAL_F = ["kral", "prens"], ["kraliçe", "prenses"]
GENDER_M, GENDER_F = ["erkek", "adam"], ["kadın", "kız"]
ANIMALS = ["köpek", "kedi", "aslan", "kartal", "balık", "kuş", "at", "tilki"]
PLACES = ["saray", "orman", "ev", "okul", "bahçe", "şehir", "köy", "deniz", "dağ", "nehir"]
VERBS_INTRANS = ["yaşar", "gider", "gelir", "uyur", "koşar", "oynar", "güler", "düşünür", "bekler", "oturur"]
FOODS = ["ekmek", "elma", "su", "çorba", "et", "pilav", "süt", "meyve"]
VERBS_EAT = ["yer", "içer"]
PROFESSIONS = ["doktor", "öğretmen", "asker", "çiftçi", "balıkçı", "tüccar", "avcı", "ressam"]
ADJ = ["mutlu", "üzgün", "kızgın", "yorgun", "meraklı", "cesur", "akıllı", "güçlü", "genç", "yaşlı"]

cumleler = []
for r in ROYAL_M:
    for g in GENDER_M:
        cumleler += [f"{r} güçlü bir {dir_ek(g)}", f"{r} genç bir {dir_ek(g)}"]
for r in ROYAL_F:
    for g in GENDER_F:
        cumleler += [f"{r} güçlü bir {dir_ek(g)}", f"{r} genç bir {dir_ek(g)}"]

# kral/kraliçe "yaşlı, ülkeyi yönetir"; prens/prenses "genç, eğitim alır" --
# bu ayrım, kral-prens'in birbirine aşırı benzemesini önler.
for r in ["kral", "kraliçe"]:
    for p in ["saray", "şehir"]:
        cumleler += [f"{r} {lokatif_ek(p)} yaşar", f"{r} {yonelme_ek(p)} gider"]
    cumleler += [f"{r} tahtta {v}" for v in ["güler", "düşünür", "bekler", "oturur"]]
    cumleler += [f"{r} yaşlı ve bilgedir", f"{r} ülkeyi yönetir"]
for r in ["prens", "prenses"]:
    for p in ["saray", "bahçe"]:
        cumleler += [f"{r} {lokatif_ek(p)} yaşar", f"{r} {yonelme_ek(p)} gider"]
    cumleler += [f"{r} sarayda {v}" for v in ["güler", "oynar", "koşar", "öğrenir"]]
    cumleler += [f"{r} genç ve enerjiktir", f"{r} eğitim alır"]

for g in GENDER_M + GENDER_F:
    for p in random.sample(PLACES, 4):
        cumleler += [f"{g} {lokatif_ek(p)} yaşar", f"{g} {yonelme_ek(p)} gider"]
    cumleler += [f"{g} {v}" for v in random.sample(VERBS_INTRANS, 4)]
    cumleler += [f"{g} çok {dir_ek(a)}" for a in random.sample(ADJ, 3)]

for a in ANIMALS:
    cumleler += [f"{a} {lokatif_ek(p)} yaşar" for p in random.sample(PLACES, 3)]
    cumleler += [f"{a} {v}" for v in random.sample(VERBS_INTRANS, 3)]
    cumleler += [f"{a} çok {dir_ek(adj)}" for adj in random.sample(ADJ, 2)]

for subj in GENDER_M + GENDER_F + ROYAL_M + ROYAL_F + PROFESSIONS:
    cumleler += [f"{subj} {f} {random.choice(VERBS_EAT)}" for f in random.sample(FOODS, 3)]

for prof in PROFESSIONS:
    cumleler += [f"{prof} {lokatif_ek(p)} çalışır" for p in random.sample(PLACES, 3)]
    cumleler += [f"{prof} çok {dir_ek(a)}" for a in random.sample(ADJ, 3)]
    cumleler += [f"{prof} {v}" for v in random.sample(VERBS_INTRANS, 3)]

random.shuffle(cumleler)
tum_kelimeler = [c.split() for c in cumleler]
dagarcik = sorted(set(w for kl in tum_kelimeler for w in kl))
kelime_indeks = {k: i for i, k in enumerate(dagarcik)}
print(f"Corpus: {len(cumleler)} cümle, {len(dagarcik)} benzersiz kelime.")
print("Örnek cümleler:", cumleler[:3])

# Word2Vec/GloVe'un ruhuna yakın, ama daha basit bir yöntem: ortak-geçiş (co-occurrence)
# sayıp PPMI ile ağırlıklandırmak, sonra SVD ile boyutu küçültmek.
PENCERE = 3
V = len(dagarcik)
ortak_gecis = np.zeros((V, V))
for kl in tum_kelimeler:
    for i, kelime in enumerate(kl):
        for j in range(max(0, i - PENCERE), min(len(kl), i + PENCERE + 1)):
            if i != j:
                ortak_gecis[kelime_indeks[kelime], kelime_indeks[kl[j]]] += 1

toplam = ortak_gecis.sum()
satir_toplam = ortak_gecis.sum(axis=1, keepdims=True)
sutun_toplam = ortak_gecis.sum(axis=0, keepdims=True)
beklenen = (satir_toplam @ sutun_toplam) / toplam
with np.errstate(divide="ignore", invalid="ignore"):
    pmi = np.log((ortak_gecis + 1e-10) / (beklenen + 1e-10))
ppmi = np.maximum(pmi, 0)  # Sadece pozitif PMI -- "Positive" PMI

U, S, Vt = np.linalg.svd(ppmi, full_matrices=False)
BOYUT = 50
embedding = U[:, :BOYUT] * S[:BOYUT]
print(f"\nOne-hot boyutu: {V} -> Embedding boyutu: {BOYUT} (yoğun, seyrek değil)")

def kosinus(a, b):
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-10))

def en_yakin(kelime, k=5):
    v = embedding[kelime_indeks[kelime]]
    benzerlikler = embedding @ v / (np.linalg.norm(embedding, axis=1) * np.linalg.norm(v) + 1e-10)
    en_iyi = np.argsort(-benzerlikler)[1 : k + 1]
    return [(dagarcik[i], round(float(benzerlikler[i]), 3)) for i in en_iyi]

print("\nEn yakın komşular (4. dersteki one-hot ile karşılaştır):")
for k in ["kral", "kraliçe", "köpek", "doktor"]:
    print(f"  {k}: {en_yakin(k)}")
print("\n4. derste 'kral'-'kraliçe' benzerliği 0.00 idi. Şimdi (yukarıda) kraliçe, kralın en yakın komşularından biri!")

# Embedding'lerin en çarpıcı özelliği: vektör aritmetiği bile anlamlı hale geliyor.
def analoji(a, b, c, k=3):
    va, vb, vc = embedding[kelime_indeks[a]], embedding[kelime_indeks[b]], embedding[kelime_indeks[c]]
    hedef = va - vb + vc
    benzerlikler = embedding @ hedef / (np.linalg.norm(embedding, axis=1) * np.linalg.norm(hedef) + 1e-10)
    haric = {kelime_indeks[a], kelime_indeks[b], kelime_indeks[c]}
    siralanmis = [i for i in np.argsort(-benzerlikler) if i not in haric][:k]
    return [(dagarcik[i], round(float(benzerlikler[i]), 3)) for i in siralanmis]

print("\nkral - erkek + kadın = ?")
print(" ", analoji("kral", "erkek", "kadın"))
print("prens - erkek + kadın = ?")
print(" ", analoji("prens", "erkek", "kadın"))
print("\nİki analoji de doğru cevabı (kraliçe, prenses) ilk sırada buluyor!")
print("Not: bu küçük (öğretici amaçlı) bir corpus'tan öğrenildi. Gerçek Word2Vec/GloVe,")
print("milyarlarca kelimelik metinle eğitilir ve çok daha güvenilir analojiler üretir.")

# EmbeddingUzayi bileşeni için: tam embedding matrisi + 2B görselleştirme projeksiyonu.
U2, S2, _ = np.linalg.svd(embedding - embedding.mean(axis=0), full_matrices=False)
projeksiyon_2b = (U2[:, :2] * S2[:2]).tolist()

kategori_haritasi = {}
for k in ROYAL_M: kategori_haritasi[k] = "kraliyet-erkek"
for k in ROYAL_F: kategori_haritasi[k] = "kraliyet-kadın"
for k in GENDER_M: kategori_haritasi[k] = "cinsiyet-erkek"
for k in GENDER_F: kategori_haritasi[k] = "cinsiyet-kadın"
for k in ANIMALS: kategori_haritasi[k] = "hayvan"
for k in PROFESSIONS: kategori_haritasi[k] = "meslek"

veri = {
    "dagarcik": dagarcik,
    "embedding": np.round(embedding, 4).tolist(),
    "projeksiyon2B": [[round(x, 4) for x in nokta] for nokta in projeksiyon_2b],
    "kategori": [kategori_haritasi.get(k, "diger") for k in dagarcik],
}
print(f"\nDışa aktarılacak: {len(dagarcik)} kelime x {BOYUT} boyut + 2B projeksiyon.")