Model Bag of Words Python: Panduan Lengkap

Bag of Words (BoW) adalah teknik dalam Natural Language Processing (NLP). Teknik ini banyak digunakan untuk mentransformasikan data teks ke format yang dapat dibaca mesin, khususnya nilai numerik, tanpa mempertimbangkan tata bahasa dan urutan kata. Memahami BoW penting bagi siapa pun yang bekerja dengan data teks. Python menyediakan beragam alat dan pustaka untuk mengimplementasikan Bag of Words secara efektif.

Dalam tutorial ini, kita akan membahas BoW, memperkenalkan konsepnya, membahas penggunaannya, dan menelusuri implementasi terperinci di Python. Di akhir tutorial ini, Anda akan dapat menerapkan model Bag of Words pada permasalahan dunia nyata. Jika Anda baru di NLP, lihat Natural Language Processing in Python skill track kami untuk mempelajari lebih lanjut. 

Apa itu Bag of Words?

Bag of Words adalah teknik untuk mengekstraksi fitur dari data teks untuk tugas pembelajaran mesin, seperti klasifikasi teks dan analisis sentimen. Ini penting karena algoritme pembelajaran mesin tidak dapat memproses data tekstual. Proses mengonversi teks menjadi angka dikenal sebagai ekstraksi fitur atau pengodean fitur.

Bag of Words didasarkan pada kemunculan kata dalam sebuah dokumen. Prosesnya dimulai dengan menemukan kosakata dalam teks dan mengukur kemunculannya. Disebut sebuah “kantong” karena urutan dan struktur kata tidak dipertimbangkan, hanya kemunculannya saja. 

Model Bag of Words berbeda dari Continuous Bag of Words (CBOW) yang mempelajari embedding kata berdimensi padat dengan menggunakan kata-kata sekitar untuk memprediksi kata target, sehingga menangkap hubungan semantik antarkata. CBOW memerlukan pelatihan pada korpus besar dan menghasilkan vektor berdimensi rendah yang berharga untuk aplikasi NLP kompleks di mana konteks kata penting.

Mengapa Menggunakan Bag of Words?

Bag of Words berguna dalam banyak tugas NLP, beberapa alasan penggunaannya antara lain:

• Ekstraksi fitur: Mengonversi data teks tidak terstruktur menjadi data terstruktur, yang dapat digunakan sebagai masukan untuk berbagai algoritme pembelajaran mesin.
• Kesederhanaan dan efisiensi: BoW sederhana secara komputasional untuk diimplementasikan, dan bekerja dengan baik untuk korpus teks berukuran kecil hingga menengah.
• Kesamaan dokumen: Dapat digunakan untuk menghitung kesamaan antar dokumen teks menggunakan teknik seperti cosine similarity.
• Klasifikasi teks: Jika digabungkan dengan teknik seperti Naive Bayes, BoW efektif untuk tugas klasifikasi teks seperti klasifikasi spam dan analisis sentimen.

Namun, ada juga kekurangan, seperti tidak mempertimbangkan semantik, struktur kata, atau pengurutan kata.

Langkah Mengimplementasikan Bag of Words di Python

Untuk membuat model bag-of-words, kita mengambil semua kata dalam sebuah korpus dan membuat kolom untuk setiap kata. Baris merepresentasikan kalimat. Jika kata tertentu ada dalam kalimat, ditandai dengan 1, dan jika kata tersebut tidak ada, ditandai dengan 0. Setiap kata pada kolom mewakili satu fitur.

Pada akhirnya, kita memperoleh matriks jarang. Matriks jarang adalah matriks dengan banyak nol. 

Prapemrosesan data

Untuk membuat model Bag of Words di Python, kita perlu melakukan beberapa langkah prapemrosesan. Langkah-langkah ini mencakup tokenisasi dan menghapus stopword.

Tokenisasi adalah proses memecah teks menjadi unit yang lebih kecil, biasanya kata. Anda dapat melakukan tokenisasi menggunakan NLTK. 

Stopword adalah kata-kata umum dalam bahasa Inggris, seperti "the," "that," dan "a," yang tidak berkontribusi pada polaritas sebuah kalimat.

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize

# Download stopwords and tokenizer if you haven't already
nltk.download("punkt")
nltk.download("stopwords")

# Example sentence
sentence = "This is an example showing how to remove stop words from a sentence."

# Tokenize the sentence into words
words = word_tokenize(sentence)

# Get the list of stop words in English
stop_words = set(stopwords.words("english"))

# Remove stop words from the sentence
filtered_sentence = [word for word in words if word.lower() not in stop_words]

# Join the words back into a sentence
filtered_sentence = " ".join(filtered_sentence)
print(filtered_sentence)Didukung oleh

Keluaran:

example showing remove stop words sentence.Didukung oleh

Membuat kosakata

Kosakata adalah kumpulan kata unik yang ditemukan dalam sebuah korpus teks. Membangun kosakata melibatkan pengumpulan semua kata unik dari korpus dan menghitung kemunculannya. Kosakata ini berguna untuk berbagai tugas NLP seperti pemodelan bahasa, word embeddings, dan klasifikasi teks.

Kode di bawah ini membuat distribusi frekuensi kata sederhana dalam korpus, berguna untuk tugas NLP dasar seperti membangun kosakata atau memahami konten teks:

• Variabel corpus memuat beberapa contoh kalimat. Dalam aplikasi nyata, ini akan berisi data teks yang lebih besar dan beragam.
• vocab = defaultdict(int) menyederhanakan penghitungan frekuensi kata, dengan otomatis menginisialisasi setiap kata baru dengan hitungan 0, sehingga memungkinkan penambahan langsung tanpa pengecekan.
• Setiap kalimat ditokenisasi dengan mengonversinya ke huruf kecil dan mengekstraksi kata menggunakan regular expression. Pola \b\w+\b mengidentifikasi kata dengan karakter alfanumerik saja, mengabaikan tanda baca dan simbol lainnya.
• Hitungan setiap kata diperbarui dalam kamus vocab.
• Kosakata diurutkan berdasarkan frekuensi secara menurun, sehingga mudah melihat kata paling umum di bagian atas, dan ditampilkan sebagai referensi.

import re  
# Import the regular expressions module to help with text processing
from collections import (
    defaultdict,
)  

# Import defaultdict to easily handle word frequency counting

# Sample corpus of text - a small dataset of sentences to analyze
corpus = [
    "Tokenization is the process of breaking text into words.",
    "Vocabulary is the collection of unique words.",
    "The process of tokenizing is essential in NLP.",
]

# Initialize a defaultdict with integer values to store word frequencies

# defaultdict(int) initializes each new key with a default integer value of 0
vocab = defaultdict(int)

# Loop through each sentence in the corpus to tokenize and normalize
for sentence in corpus:
    # Convert the sentence to lowercase to ensure consistency in counting (e.g., 'Tokenization' and 'tokenization' are treated as the same word)
    # Use regular expressions to find words composed of alphanumeric characters only
    words = re.findall(r"\b\w+\b", sentence.lower())
    # For each word found, increment its count in the vocab dictionary
    for word in words:
        vocab[word] += 1

# Convert the defaultdict vocab to a regular dictionary for easier handling and sorting

# Sort the dictionary by word frequency in descending order and convert it to a new dictionary
sorted_vocab = dict(sorted(vocab.items(), key=lambda x: x[1], reverse=True))

# Display the sorted vocabulary with each word and its frequency count
print("Vocabulary with Frequencies:", sorted_vocab)Didukung oleh

Keluaran:

Vocabulary with Frequencies: {'is': 3, 'the': 3, 'of': 3, 'process': 2, 'words': 2, 'tokenization': 1, 'breaking': 1, 'text': 1, 'into': 1, 'vocabulary': 1, 'collection': 1, 'unique': 1, 'tokenizing': 1, 'essential': 1, 'in': 1, 'nlp': 1}Didukung oleh

Membangun kosakata secara manual bisa memakan waktu, terutama untuk korpus besar. CountVectorizer dari Scikit-learn mengotomatiskan proses ini dan memungkinkan pemrosesan teks yang lebih fleksibel seperti yang akan kita lihat nanti. 

Implementasi Bag of Words Menggunakan Python (Dari Nol)

Mari mulai dengan implementasi sederhana Bag of Words dari nol di Python. Ini akan membantu Anda memahami komponen penyusun dan mekanisme cara kerjanya di balik layar.

Implementasi manual

Langkah 1: Prapemrosesan Data Teks

Kita akan mulai dengan mendefinisikan fungsi sederhana untuk memroses teks, termasuk tokenisasi, mengubah ke huruf kecil, dan menghapus tanda baca.

from collections import defaultdict
import string

# Sample text data: sentences
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Function to preprocess text
def preprocess(text):
    # Convert to lowercase
    text = text.lower()
    # Remove punctuation
    text = text.translate(str.maketrans("", "", string.punctuation))
    # Tokenize: split the text into words
    tokens = text.split()
    return tokens

# Apply preprocessing to the sample corpus
processed_corpus = [preprocess(sentence) for sentence in corpus]
print(processed_corpus)Didukung oleh

Keluaran:

[['python', 'is', 'amazing', 'and', 'fun'], ['python', 'is', 'not', 'just', 'fun', 'but', 'also', 'powerful'], ['learning', 'python', 'is', 'fun']]Didukung oleh

Langkah 2: Membangun Kosakata

Sekarang, kita perlu memindai semua dokumen dan membangun daftar lengkap kata unik, yaitu kosakata kita.

# Initialize an empty set for the vocabulary
vocabulary = set()

# Build the vocabulary
for sentence in processed_corpus:
    vocabulary.update(sentence)

# Convert to a sorted list
vocabulary = sorted(list(vocabulary))
print("Vocabulary:", vocabulary)Didukung oleh

Langkah 3: Menghitung Frekuensi Kata dan Melakukan Vektorisasi

Sekarang kita akan menghitung frekuensi setiap kata dalam kosakata untuk setiap dokumen dalam korpus yang telah diproses.

def create_bow_vector(sentence, vocab):
    vector = [0] * len(vocab)  # Initialize a vector of zeros
    for word in sentence:
        if word in vocab:
            idx = vocab.index(word)  # Find the index of the word in the vocabulary
            vector[idx] += 1  # Increment the count at that index
    return vector
Didukung oleh

Pada titik ini, Anda telah membuat representasi Bag of Words untuk setiap dokumen dalam korpus Anda.

# Create BoW vector for each sentence in the processed corpus
bow_vectors = [create_bow_vector(sentence, vocabulary) for sentence in processed_corpus]
print("Bag of Words Vectors:")
for vector in bow_vectors:
    print(vector)
Didukung oleh

Keluaran:

Bag of Words Vectors:
[0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1]
[0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1]Didukung oleh

Menggunakan CountVectorizer dari Scikit-learn

Membangun model Bag of Words secara manual bagus untuk belajar, tetapi untuk aplikasi produksi, Anda akan ingin menggunakan pustaka yang efisien dan teroptimasi seperti Scikit-learn.

Fungsi Python yang kita gunakan untuk tokenisasi adalah CountVectorizer, yang diimpor dari sklearn.feature_extraction.text. Salah satu fitur CountVectorizer adalah max_features, yang merepresentasikan jumlah maksimum kata yang ingin Anda miliki dalam model bag of words. Dalam kasus ini, kita gunakan None, artinya semua fitur akan digunakan. 

Setelah membuat instance CountVectorizer, gunakan metode .fit_transform() untuk membuat model bag of words. Selanjutnya, gunakan .toarray() untuk mengonversi model bag of words menjadi array numpy yang dapat diberikan ke model pembelajaran mesin.

Setelah dipasang, CountVectorizer telah membangun kamus indeks fitur. Nilai indeks sebuah kata dalam kosakata ditautkan ke frekuensinya di seluruh korpus pelatihan.

from sklearn.feature_extraction.text import CountVectorizer
# Original corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]
# Create a CountVectorizer Object
vectorizer = CountVectorizer()
# Fit and transform the corpus
X = vectorizer.fit_transform(corpus)
# Print the generated vocabulary
print("Vocabulary:", vectorizer.get_feature_names_out())
# Print the Bag-of-Words matrix
print("BoW Representation:")
print(X.toarray())Didukung oleh

Keluaran:

markdownVocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'

 'powerful' 'python']

BoW Representation:

[[0 1 1 0 1 1 0 0 0 0 1]

 [1 0 0 1 1 1 1 0 1 1 1]

 [0 0 0 0 1 1 0 1 0 0 1]]Didukung oleh

Contoh: Menerapkan Bag of Words

Sekarang mari terapkan model BoW pada korpus teks kecil yang terdiri dari tiga ulasan film untuk menggambarkan seluruh proses. 

Kita akan menggunakan CountVectorizer dari Scikit-learn untuk menerapkan model BoW pada korpus teks kecil ini.

Berikut langkah-langkah yang akan kita lakukan:

• CountVectorizer secara otomatis melakukan tokenisasi teks, menghapus tanda baca, dan mengubah kata menjadi huruf kecil.
• .fit_transform(corpus) mengonversi korpus menjadi matriks dokumen-term, di mana setiap baris merepresentasikan dokumen dan setiap kolom merepresentasikan kata dari kosakata.
• X_dense adalah matriks padat yang merepresentasikan frekuensi setiap kata pada setiap dokumen.

from sklearn.feature_extraction.text import CountVectorizer
# Sample corpus of movie reviews
corpus = [
    "I loved the movie, it was fantastic!",
    "The movie was okay, but not great.",
    "I hated the movie, it was terrible.",
]

# Initialize the CountVectorizer
vectorizer = CountVectorizer()

# Fit and transform the corpus to a document-term matrix
X = vectorizer.fit_transform(corpus)

# Convert the document-term matrix into a dense format (optional for visualization)
X_dense = X.toarray()

# Get the vocabulary (mapping of words to index positions)
vocab = vectorizer.get_feature_names_out()

# Print the vocabulary and document-term matrix
print("Vocabulary:", vocab)
print("Document-Term Matrix:\n", X_dense)Didukung oleh

Keluaran:

Vocabulary: ['but' 'fantastic' 'great' 'hated' 'it' 'loved' 'movie' 'not' 'okay' 'terrible' 'the' 'was']
Document-Term Matrix:
 [[0 1 0 0 1 1 1 0 0 0 1 1]  # First review: "I loved the movie, it was fantastic!"
  [1 0 1 0 1 0 1 1 1 0 1 1]  # Second review: "The movie was okay, but not great."
  [0 0 0 1 1 0 1 0 0 1 1 1]] # Third review: "I hated the movie, it was terrible."Didukung oleh

Berikut cara menafsirkan keluaran di atas:

• Setiap kata unik dalam korpus diberi indeks, dan kata-kata diurutkan secara alfabetis. Misalnya, "but" berada pada indeks 0, "fantastic" pada indeks 1, "movie" pada indeks 6, dan seterusnya.
•  Setiap baris dalam matriks dokumen merepresentasikan sebuah ulasan film, dan setiap kolom sesuai dengan kata dari kosakata. Nilai dalam matriks merepresentasikan frekuensi setiap kata dalam dokumen tersebut.
• Ulasan Pertama: [0 1 0 0 1 1 1 0 0 0 1 1] menunjukkan bahwa:
• Kata "fantastic" muncul sekali (1 pada indeks 1),
• Kata "loved" muncul sekali (1 pada indeks 5),
• Kata "movie" muncul sekali (1 pada indeks 6),
• Kata "it" muncul sekali (1 pada indeks 4),
• Dan seterusnya.

Vektor BoW dapat ditafsirkan sebagai berikut:

• Setiap dokumen adalah vektor angka yang merepresentasikan jumlah kata. Dimensi vektor sama dengan ukuran kosakata. Dalam kasus ini, kosakata memiliki 12 kata, sehingga setiap ulasan diubah menjadi vektor berdimensi 12.
• Sebagian besar kata pada setiap baris bernilai nol karena tidak setiap dokumen memuat setiap kata dari kosakata. Oleh karena itu, model BoW sering kali bersifat jarang, yaitu memiliki banyak nol.

Kelebihan dan Keterbatasan Bag of Words

Sekarang mari membahas beberapa kelebihan dan keterbatasan model Bag of Words.

Kelebihan

1. Mudah diimplementasikan dan ditafsirkan: Model Bag of Words adalah salah satu teknik representasi teks yang paling sederhana, sehingga ideal bagi pemula. Kesederhanaannya memungkinkan implementasi cepat tanpa perlu prapemrosesan kompleks atau model khusus.
2. Mudah digunakan untuk tugas klasifikasi teks: Bag of Words cocok untuk tugas dasar seperti klasifikasi teks, analisis sentimen, dan deteksi spam. Tugas-tugas ini sering tidak memerlukan model bahasa yang canggih, sehingga representasi BOW sudah memadai dan efisien.

Keterbatasan

1. Ukuran kosakata memengaruhi kelangkaan representasi: Semakin besar kosakata, semakin jarang dan berdimensi tinggi representasinya. Kelangkaan ini dapat menyulitkan model untuk belajar secara efektif dan memerlukan penyetelan ukuran kosakata agar tidak menimbulkan biaya komputasi yang berlebihan.
2. Menghasilkan matriks jarang yang mahal secara komputasi: Karena setiap dokumen direpresentasikan oleh frekuensi setiap kata dalam kosakata yang berpotensi besar, matriks yang dihasilkan sering kali sebagian besar bernilai nol, yang bisa tidak efisien untuk disimpan dan diproses dalam pipeline pembelajaran mesin. Matriks jarang mengonsumsi memori signifikan dan sering memerlukan alat serta pustaka khusus untuk penyimpanan dan komputasi yang efisien, terutama pada dataset besar.
3. Kehilangan makna dan konteks: BOW mengabaikan urutan kata dan struktur kalimat, yang mengakibatkan hilangnya hubungan gramatikal dan makna. Keterbatasan ini membuatnya kurang cocok untuk tugas yang memerlukan konteks, nuansa, dan urutan kata, seperti penerjemahan atau deteksi sentimen pada kalimat kompleks.

Strategi berikut dapat digunakan untuk mengurangi ukuran kosakata dalam Bag of Words:

• Mengabaikan huruf besar-kecil. 
• Menghapus tanda baca.
• Menghapus stopword, yaitu kata umum seperti the dan a. 
• Memastikan semua kata dieja dengan benar. 
• Menggunakan teknik stemming untuk mengurangi kata ke bentuk dasarnya.

Langkah Berikutnya: Melampaui Bag of Words

Salah satu keterbatasan model Bag of Words adalah memperlakukan semua kata secara setara. Sayangnya, hal ini dapat menimbulkan masalah ketika beberapa kata diberi bobot lebih hanya karena sering muncul. 

TF-IDF (Term Frequency-Inverse Document Frequency) adalah solusi untuk masalah ini, karena menyesuaikan bobot kata berdasarkan seberapa sering kata tersebut muncul di seluruh dokumen.

TF-IDF: Perluasan untuk Bag of Words

Term Frequency (TF) merepresentasikan frekuensi sebuah term dalam dokumen. Inverse Document Frequency (IDF) mengurangi dampak kata-kata yang umum muncul di banyak dokumen. Skor TF-IDF dihitung dengan mengalikan kedua metrik tersebut. 

Pertimbangkan sebuah dokumen yang berisi 200 kata, di mana kata love muncul 5 kali. TF untuk love adalah (5 / 200) = 0,025. Misalkan kita memiliki satu juta dokumen dan kata love muncul pada seribu dokumen, maka inverse document frequency (IDF) dihitung sebagai log(1000000 / 1000) = 3. Bobot TF-IDF adalah hasil perkalian kedua besaran tersebut: 0,025 * 3 = 0,075.

Di Scikit-learn, ini relatif mudah dihitung menggunakan kelas TfidfVectorizer.

from sklearn.feature_extraction.text import TfidfVectorizer
# Sample corpus
corpus = [
    "Python is amazing and fun.",
    "Python is not just fun but also powerful.",
    "Learning Python is fun!",
]

# Create the Tf-idf vectorizer
tfidf_vectorizer = TfidfVectorizer()

# Fit and transform the corpus
X_tfidf = tfidf_vectorizer.fit_transform(corpus)

# Show the Vocabulary
print("Vocabulary:", tfidf_vectorizer.get_feature_names_out())

# Show the TF-IDF Matrix
print("TF-IDF Representation:")
print(X_tfidf.toarray())Didukung oleh

Keluaran:

Vocabulary: ['also' 'amazing' 'and' 'but' 'fun' 'is' 'just' 'learning' 'not'
 'powerful' 'python']
TF-IDF Representation:
[[0.         0.57292883 0.57292883 0.         0.338381   0.338381
  0.         0.         0.         0.         0.338381  ]
 [0.40667606 0.         0.         0.40667606 0.24018943 0.24018943
  0.40667606 0.         0.40667606 0.40667606 0.24018943]
 [0.         0.         0.         0.         0.41285857 0.41285857
  0.         0.69903033 0.         0.         0.41285857]]
Didukung oleh

Matriks TF-IDF yang diimplementasikan di atas memberikan ukuran berbobot alih-alih frekuensi mentah.

Walaupun model Bag of Words memiliki keterbatasan, terutama untuk dataset yang lebih besar dan kompleks, model ini tetap menjadi fondasi penting dalam banyak aplikasi NLP. Memahaminya akan membantu Anda saat mengeksplorasi model yang lebih maju seperti word embeddings dan Transformers.

Dari sini, Anda dapat bereksperimen dengan BoW dalam proyek Anda, termasuk deteksi spam, analisis sentimen, pengelompokan dokumen, dan lainnya.

Jika Anda menginginkan peningkatan lebih lanjut melampaui Bag of Words, Anda dapat mengeksplorasi metode seperti Word2Vec, dan GloVe, atau model deep learning seperti BERT.

Pemikiran Akhir

Teknik Bag of Words adalah teknik fundamental yang digunakan dalam Natural Language Processing. Teknik ini berfungsi sebagai cara sederhana namun efektif untuk mengonversi teks tidak terstruktur menjadi fitur numerik yang dapat digunakan oleh algoritme pembelajaran mesin. Dalam tutorial ini, kami telah membahas:

• Apa itu model Bag of Words (BoW)?
• Manfaat model Bag of Word dalam membangun model pembelajaran mesin.
• Cara mengimplementasikan model Bag of Words di Python.
•  Kelebihan dan keterbatasan Bag of Words.
• Teori dan motivasi di balik model Bag of Words.
• Pengenalan TF-IDF sebagai peningkatan terhadap pendekatan Bag of Words tradisional.

Lihat Natural Language Processing in Python skill track kami untuk mendalami pemrosesan bahasa alami.