# Representasi Teks
Pemrosesan Bahasa alami adalah bidang yang berkembang yang memungkinkan mesin untuk memproses dan memahami bahasa manusia. Representasi teks didalam pemrosesan bahasa alami adalah komponen penting yang merubah teks menjadi bentuk lain sehingga mesin dapat mengolahnya.

Pada bagian ini saya akan menjelaskan beberapa dari representasi teks didalam NLP
yaitu :
* Bag of word
* N-gram
* TF-IDF
* Word Embedding
* Sentence Embedding
* Document Embedding

### **Bag of Words (BoW)**

Bag of Words (BoW) adalah salah satu teknik paling dasar dan umum dalam *natural language processing* (NLP) untuk merepresentasikan teks ke dalam bentuk numerik yang bisa dipahami oleh mesin.

Bag of word mengubah dokumen menjadi vektor frekuensi kata, **tanpa memperhatikan urutan atau struktur sintaksis**, hanya jumlah kemunculan setiap kata.

Istilah "tas kata" (bag of words) menggambarkan ide bahwa seperti tas, semua kata dicampur bersama — posisi dan urutannya tidak penting.

#### Cara Kerja BoW

1. **Buat daftar kosakata (vocabulary)** dari semua kata unik yang muncul di seluruh dokumen.
2. **Representasikan setiap dokumen** sebagai vektor, di mana:
- Setiap elemen = jumlah kemunculan (frekuensi) satu kata dari kosakata dalam dokumen tersebut.

**Contoh**
Perhatikan 3 kalimat berikut:

1. The cat in the hat
2. The dog in the house
3. The Bird in the Sky

Berikut adalah representasi **Bag of Words (BoW)** dari ketiga kalimat tersebut:

| Text | dog | cat | bird | in | house | sky | the | hat |
|----------------------|-----|-----|------|----|-------|-----|-----|-----|
| The cat in the hat | 0 | 1 | 0 | 1 | 0 | 0 | 2 | 1 |
| The dog in the house | 1 | 0 | 0 | 1 | 1 | 0 | 2 | 0 |
| The bird in the sky | 0 | 0 | 1 | 1 | 0 | 1 | 2 | 0 |

- Setiap kolom mewakili satu kata dalam kamus (vocabulary).
- Nilai di setiap sel menunjukkan jumlah kemunculan kata tersebut dalam kalimat.
- Kata seperti *"the"* muncul dua kali dalam setiap kalimat, sehingga nilainya adalah 2.
- Kata yang tidak muncul dalam suatu kalimat memiliki nilai 0.

Bag of wor mudah diimplementasikan dalam membangun representasi teks serta efektif untuk tugas tugas seperti klasifikasi teks (spam detection, analisis sentimen). Selain itu dapat digunaka untuk representasi input pada algoritma algoritma ML seperti Naive Bayes, SVM, dll.
Bag of word memiliki kekurangan diantaranya:
- **Mengabaikan urutan kata**
Kalimat *"dog bites man"* dan *"man bites dog"* akan memiliki representasi yang sama.
- **Dimensi tinggi**: Jika kosakata besar, vektor jadi sangat panjang (sparse).
- **Tidak menangkap makna semantik**: Kata seperti *"good"* dan *"great"* dianggap berbeda meskipun mirip maknanya.
- **Tidak membedakan kata penting**: Semua kata diperlakukan sama, kecuali jika dikombinasikan dengan metode lain seperti TF-IDF.

Source Code

from sklearn.feature_extraction.text import CountVectorizer

# Contoh kalimat
sentences = ["The cat in the hat",
             "The dog in the house",
             "The bird in the sky"]

# Buat objek CountVectorizer
vectorizer = CountVectorizer()

# Gunakan fit_transform untuk mengubah kalimat menjadi BoW
bow = vectorizer.fit_transform(sentences)

# Cetak kamus (fitur) dari BoW
print(vectorizer.get_feature_names_out())

# Cetak matriks BoW sebagai array
print(bow.toarray())

['bird' 'cat' 'dog' 'hat' 'house' 'in' 'sky' 'the']
[[0 1 0 1 0 1 0 2]
 [0 0 1 0 1 1 0 2]
 [1 0 0 0 0 1 1 2]]

### N-gram

**N-gram** adalah sebuah *urutan dari n item* dalam teks, yang digunakan dalam *pemrosesan bahasa alami (NLP)* dan *model bahasa statistik*. Item tersebut biasanya berupa kata, huruf, atau token.

N-gram dapat meemecah teks menjadi urutan kata berurutan sepanjang n-kata.**

- **Uni-gram** memberikan semua kata dalam sebuah kalimat.
- **Bi-gram** memberikan pasangan dua kata berurutan.
- **Tri-gram** memberikan kelompok tiga kata berurutan, dan seterusnya.

**Contoh N-gram Nilai `n`**

| N | Nama | Contoh dari kalimat: *"I love machine learning"* |
|---|------------|----------------------------------------------------|
| 1 | **Unigram** | "I", "love", "machine", "learning" |machine", "machine learning" |
| 3 | **Trigram** | "I love machine", "love machine learning" |
| 4 | **4-gram** | "I love machine learning" |

> Semakin besar nilai `n`, semakin banyak konteks urutan yang ditangkap.

---

N-gram dapat menangkap **konteks lokal** dibandingkan dengan BoW. N-gram memiliki kekurangan diantaranya

- **Kombinatorial explosion**: Semakin besar `n`, jumlah kemungkinan n-gram meningkat drastis → membutuhkan memori besar.
- **Sparse problem**: Banyak n-gram yang tidak pernah muncul dalam data pelatihan → probabilitas nol.
- **Tidak generalisasi**: Tidak bisa menangani n-gram yang belum pernah dilihat (*out-of-vocabulary*).
- **Mengabaikan makna semantik**: Tidak tahu bahwa *"good"* dan *"great"* mirip jika tidak muncul dalam pola yang sama.

Untuk mengatasi masalah ini, digunakan teknik seperti:
- **Smoothing** (misalnya Laplace, Good-Turing)
- **Backoff & Interpolation**

**Contoh Implementasi Sederhana (Python)**

from nltk import ngrams

text = "I love machine learning"
tokens = text.split()

# Bigram (n=2)
bigrams = list(ngrams(tokens, 2))
print(bigrams)
# Output: [('I', 'love'), ('love', 'machine'), ('machine', 'learning')]

### Perbandingan dengan Bag of Words (BoW)

| Fitur | Bag of Words | N-gram |
|------------------|------------------------|----------------------------|
| Urutan kata | Diabaikan | Dipertahankan |
| Representasi | Frekuensi kata | Frekuensi frasa/urutan |
| Konteks | Tidak ada | Ada (lokal) |
| Ukuran vektor | Lebih kecil | Lebih besar (tergantung n) |
| Performa | Baik untuk klasifikasi | Lebih baik untuk prediksi |

---
## TF-IDF:

TF-IDF adalah singkatan dari Term Frequency-Inverse Document Frequency. Metode ini lebih baik daripada BoW karena mampu menafsirkan tingkat pentingnya suatu kata dalam sebuah dokumen. Ide di balik TF-IDF adalah memberi bobot pada kata-kata berdasarkan seberapa sering kata tersebut muncul dalam dokumen (frekuensi istilah) dan seberapa umum kata tersebut di seluruh dokumen (frekuensi dokumen terbalik).

Rumus untuk menghitung skor TF-IDF suatu kata dalam sebuah dokumen adalah:

$$ \text{TF-IDF}(t, d) = \text{tf}(t, d) \times \log\left( \frac{N}{\text{df}(t)} \right)$$

Di mana:
- $t$ = kosa kata (term),
- $d$ = dokumen,
- $N$ = total jumlah dokumen,
- $\text{tf}(t, d)$ = frekuensi istilah $t$ dalam dokumen $d$,
- $\text{df}(t)$ = jumlah dokumen yang berisi istilah $t$.

**Contoh**

| Text | bird | cat | flying | in | jumped | roared | sky | the | tiger | white |
|-----------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|
| The cat jumped | 0 | 0.5844 | 0 | 0 | 0.5844 | 0 | 0 | 0.3452 | 0 | 0 |
| The white tiger roared| 0 | 0 | 0 | 0 | 0 | 0.5464 | 0 | 0.3227 | 0.5464 | 0.5464 |
| Bird flying in the sky| 0.5046 | 0 | 0.5046 | 0.3838 | 0 | 0 | 0.5046 | 0.2980 | 0 | 0 |

from sklearn.feature_extraction.text import TfidfVectorizer
# Example documents
docs = ["The cat jumped",
        "The white tiger roared",
        "Bird flying in the sky"]  
# Create a TfidfVectorizer object
vectorizer = TfidfVectorizer()
# Use the fit_transform method to transform the documents into a TF-IDF matrix
tfidf = vectorizer.fit_transform(docs)
# Print the vocabulary (features) of the TF-IDF matrix
print(vectorizer.get_feature_names())
# Print the TF-IDF matrix
print(tfidf.toarray())

### Word Embedding
Representasi kata (word embedding) menggambarkan setiap kata sebagai vektor padat dari bilangan real, sehingga kata-kata yang mirip atau saling berkaitan secara semantik berada lebih dekat satu sama lain dalam ruang vektor. Hal ini dicapai dengan melatih model jaringan saraf tiruan pada korpus teks yang besar, di mana setiap kata direpresentasikan sebagai input unik dan jaringan belajar memprediksi kata-kata di sekitarnya dalam teks. Makna semantik kata ditangkap melalui proses ini. Dimensi dari representasi kata-kata ini dapat bervariasi, mulai dari beberapa ratus (Glove, Word2vec) hingga ribuan (model bahasa).