📝 NLP: Teks Menjadi Angka

Tokenisasi, Bag-of-Words, TF-IDF — fondasi klasik sebelum era embedding & transformer.

🎬 Animasi: NLP: Teks Menjadi Vektor

Kalimat di-tokenize, frekuensi tiap kata dihitung, lalu menjadi vektor angka (bag of words).

📌 1. Pipeline: Dari Kata ke Vektor

Model ML hanya paham ANGKA. Teks harus diubah dulu:

"Film bagus dan seru"
   │ 1. TOKENIZE (pecah per kata, lowercase)
   ▼
["film", "bagus", "dan", "seru"]
   │ 2. BANGUN VOCABULARY (daftar kata unik dari semua dokumen)
   ▼
vocab = [bagus, dan, film, seru]
   │ 3. BAG-OF-WORDS (hitung frekuensi tiap kata)
   ▼
[1, 1, 1, 1]   ← vektor! (urutan sesuai vocab)

Bag-of-Words = vektor frekuensi kata. Urutan kata DIABAIKAN
("bagus film" = "film bagus") — itu kelemahan utamanya.

TF-IDF = perbaikan: kata yang muncul di SEMUA dokumen
("dan", "di") diberi bobot KECIL; kata langka & khas diberi
bobot BESAR.
    TF  = frekuensi kata di dokumen
    IDF = ln((N+1)/(df+1)) + 1     (df = jumlah dokumen yang
                                     mengandung kata itu)
    bobot = TF × IDF

📌 2. Contoh: Analisis Sentimen (BoW + Logistic Regression)

print("=== SENTIMEN ANALYSIS: BoW + LOGISTIC REGRESSION ===\n")
train = [
    ("film bagus seru dan menghibur", 1),
    ("akting luar biasa cerita menarik", 1),
    ("sangat recommended wajib tonton", 1),
    ("musiknya enak ceritanya asyik", 1),
    ("film jelek membosankan dan ngantuk", 0),
    ("cerita tidak masuk akal akting buruk", 0),
    ("sangat kecewa buang waktu", 0),
    ("boring plotnya kacau", 0),
]

def tokenize(t):
    return [w for w in t.lower().replace(",", " ").split() if w]

vocab = sorted(set(w for t, _ in train for w in tokenize(t)))
print("Vocabulary (%d kata): %s" % (len(vocab), vocab))

def bow(text):
    words = tokenize(text)
    return [words.count(w) for w in vocab]

Xb = [bow(t) for t, _ in train]
yb = [l for _, l in train]

# Logistic regression (seperti bab 5)
w = [0.0] * (len(vocab) + 1)
for epoch in range(300):
    for i in range(len(Xb)):
        x = [1.0] + Xb[i]
        p = sigmoid(dot(w, x))
        w = vec_sub(w, vec_scale(x, 0.1 * (p - yb[i])))

print("\nBobot kata (positif = mendorong ke POSITIF):")
for j, word in enumerate(vocab):
    if abs(w[j + 1]) > 0.05:
        print("  %-12s %+.2f" % (word, w[j + 1]))

print("\nUji kalimat baru:")
tests = [
    "film seru dan menghibur",
    "sangat membosankan kecewa",
    "akting menarik recommended",
    "boring kacau buang waktu",
]
for text in tests:
    x = [1.0] + bow(text)
    p = sigmoid(dot(w, x))
    print("  P(positif)=%.3f  [%s]  '%s'"
          % (p, "POSITIF" if p >= 0.5 else "NEGATIF", text))

Output:

Perhatikan: kata "sangat" bisa menjadi positif ATAU negatif tergantung konteks ("sangat recommended" vs "sangat kecewa") — BoW tidak bisa menangkap itu. Inilah yang dipecahkan word embedding dan transformer (era modern).

📌 3. Contoh: Pencarian Dokumen (TF-IDF + Cosine Similarity)

print("=== PENCARIAN DOKUMEN: TF-IDF + COSINE ===\n")
docs = [
    "machine learning adalah cabang artificial intelligence",
    "neural network dipakai untuk deep learning",
    "resep nasi goreng dengan telur dan bawang",
    "cuaca hari ini hujan di surabaya",
]

def tokenize(t):
    return [w for w in t.lower().split() if w]

vocab = sorted(set(w for d in docs for w in tokenize(d)))
N = len(docs)

# TF
tf = [[tokenize(d).count(w) for w in vocab] for d in docs]
# IDF
idf = []
for j, w in enumerate(vocab):
    df = sum(1 for d in docs if w in tokenize(d))
    idf.append(math.log((N + 1) / (df + 1)) + 1)
# TF-IDF
tfidf = [[tf[i][j] * idf[j] for j in range(len(vocab))] for i in range(N)]

print("IDF beberapa kata (tinggi = khas/langka):")
for w in ["learning", "adalah", "nasi", "hujan"]:
    j = vocab.index(w)
    print("  %-10s idf = %.2f" % (w, idf[j]))

print("\nQuery: 'deep machine learning'")
qwords = tokenize("deep machine learning")
q = [qwords.count(w) for w in vocab]
q = [q[j] * idf[j] for j in range(len(vocab))]

print("Hasil ranking (cosine similarity):")
results = []
for i, d in enumerate(docs):
    sim = cosine_sim(q, tfidf[i])
    results.append((sim, i))
for sim, i in sorted(results, reverse=True):
    print("  sim=%.3f  '%s'" % (sim, docs[i]))

print("\nKata 'learning' muncul di 2 dokumen → idf-nya lebih rendah")
print("daripada 'hujan' (1 dokumen). Kata umum tidak terlalu")
print("mempengaruhi ranking — itulah inti TF-IDF.")

Output:

💡 Evolution NLP: BoW/TF-IDF (klasik) → word2vec/GloVe (embedding: kata jadi vektor bermakna, "raja - laki + perempuan ≈ ratu") → BERT/GPT (transformer: konteks dinamis). Prinsip "teks → vektor → model" tetap sama — hanya cara pembuatannya yang makin pintar.

🧠 Latihan

Tambahkan 4 kalimat training sentimen baru. Apakah bobot kata "sangat" berubah?
Ganti logistic regression dengan Naive Bayes (bab 8). Bandingkan hasilnya.
Buat query "resep telur bawang" di contoh TF-IDF. Dokumen mana yang menang?
Jelaskan kenapa BoW gagal pada kalimat "film ini tidak jelek". (Petunjuk: kata "tidak" kehilangan makna negasi.)