Selamat datang di dunia analisis sentimen! Di era digital saat ini, di mana setiap tweet, ulasan, atau komentar dapat berdampak pada reputasi bisnis, pemahaman dan analisis sentimen menjadi hal yang sangat penting. Baik Anda ingin mengukur kepuasan pelanggan, melacak tren percakapan media sosial, atau memprediksi opini publik tentang peluncuran produk — analisis sentimen adalah alat utama Anda. Dan cara apa yang lebih baik untuk mendalami subjek menarik ini selain dengan membuat model analisis sentimen Anda sendiri menggunakan algoritma Naive Bayes dengan Python? Jadi, bersiaplah untuk mengungkap rahasia di balik pengklasifikasian emosi dan opini dengan tepat dan akurat. Mari kita memulai perjalanan mengasyikkan ini bersama-sama!

Pengantar Analisis Sentimen

Analisis sentimen adalah proses menentukan apakah suatu teks bersifat positif, negatif, atau netral. Ini dapat digunakan untuk menganalisis postingan media sosial, ulasan, artikel, dll. Ada berbagai metode untuk melakukan analisis sentimen, namun kami akan menggunakan algoritma Naive Bayes dalam artikel ini.

Algoritma Naive Bayes adalah pendekatan probabilistik yang membuat prediksi berdasarkan bukti dan probabilitas sebelumnya. Ini sering digunakan dalam tugas klasifikasi teks karena sederhana dan efisien. Dalam kasus kami, kami akan menggunakannya untuk memprediksi apakah suatu teks positif atau negatif.

Jika Anda belum familiar dengan algoritma Naive Bayes, jangan khawatir! Kami akan membahas semua yang perlu Anda ketahui di artikel ini. Kami juga akan memberikan cuplikan kode sehingga Anda dapat mengikutinya di rumah.

Apa itu Algoritma Naive Bayes?

Algoritma Naive Bayes merupakan teknik klasifikasi berdasarkan Teorema Bayes. Ini digunakan untuk memprediksi kelas suatu observasi dengan mempertimbangkan serangkaian fitur. Algoritma Naive Bayes dianggap sebagai salah satu algoritma pembelajaran mesin yang paling sederhana dan kuat.

Algoritma Naive Bayes didasarkan pada konsep probabilitas bersyarat. Hal ini membuat asumsi bahwa kehadiran fitur tertentu di suatu kelas tidak berhubungan dengan kehadiran fitur lain di kelas tersebut. Asumsi ini disebut independensi bersyarat kelas.

Algoritma Naive Bayes dapat diterapkan pada masalah klasifikasi apa pun di mana kita memiliki sekumpulan fitur dan ingin memprediksi label kelasnya. Beberapa contoh umum adalah:

Pemfilteran spam: Kami memiliki sekumpulan email, masing-masing diwakili oleh sekumpulan kata (fitur), dan kami ingin mengklasifikasikannya sebagai spam atau bukan spam.

Klasifikasi dokumen: Kami memiliki sekumpulan dokumen, masing-masing diwakili oleh sekumpulan kata (fitur), dan kami ingin mengklasifikasikannya ke dalam kategori berbeda (misalnya, olahraga, politik, teknologi, dll.).

Analisis sentimen: Kami memiliki serangkaian ulasan film, masing-masing diwakili oleh serangkaian kata (fitur), dan kami ingin mengklasifikasikannya sebagai positif atau negatif.

Identifikasi Penulis: Dengan adanya kumpulan data teks tertulis, yang masing-masing diwakili oleh kata (fitur), tujuannya adalah untuk mengidentifikasi kemungkinan penulis dari sekumpulan penulis potensial. Hal ini melibatkan analisis gaya penulisan dan pola bahasa untuk mengaitkan teks tertentu dengan penulisnya masing-masing.

Ikhtisar Kumpulan Data

Dataset yang digunakan untuk proyek ini adalah dataset “Tweet Sentiment Extraction” dari Kaggle. Kumpulan data ini berisi tweet beserta label sentimen terkait dan teks yang dipilih. Teks yang dipilih memberikan representasi singkat tentang sentimen tweet tersebut. Dataset tersebut digunakan untuk melatih model analisis sentimen untuk memprediksi sentimen tweet.

Kolom

  • textID: ID unik untuk setiap bagian teks.
  • teks: Teks tweet.
  • sentimen: Label sentimen umum pada tweet (positif, negatif, atau netral).
  • selected_text(Khusus pelatihan): Teks yang mendukung sentimen tweet, berfungsi sebagai indikator sentimen.

Kami hanya fokus pada kolom “teks” yang berisi konten tweet, dan kolom “sentimen” yang menunjukkan apakah sentimen tweet tersebut positif, negatif, atau netral. Kolom lain seperti “textID” dan “selected_text” tidak termasuk dalam cakupan minat kami.

Pernyataan Masalah Kumpulan Data

Berdasarkan teks tweet, tugasnya adalah mengklasifikasikan sentimen menjadi positif, negatif, atau netral. Hal ini melibatkan pelatihan model untuk memahami nada emosional teks.

Langkah

Berikut penjelasan lebih detail setiap langkah membuat model analisis sentimen menggunakan algoritma Naive Bayes dengan Python:

  1. Dapatkan kumpulan data dengan tweet positif dan negatif: Pada langkah pertama, kami akan mengekstrak tweet dengan sentimen positif dan negatif dari kumpulan data. Hal ini dapat dicapai dengan menggunakan fungsi split_data_by_sentiment pada DataFrame, yang memisahkan data ke dalam daftar tweet positif dan negatif yang terpisah.
def split_data_by_sentiment(data, sentiment):
    """
    Split the data DataFrame into separate lists based on sentiment.

    Parameters:
       data (DataFrame): The input DataFrame containing 'text' and 'sentiment' columns.
       sentiment (str): The sentiment label to filter the data.

    Returns:
        list: A list of text corresponding to the specified sentiment.
    """
    return data[data['sentiment'] == sentiment]['text'].tolist()

# Assuming df is your DataFrame containing 'text' and 'sentiment' columns
positive_data = split_data_by_sentiment(df, 'positive')
negative_data = split_data_by_sentiment(df, 'negative')
neutral_data = split_data_by_sentiment(df, 'neutral')

2. Memproses terlebih dahulu tweet: Sebelum menggunakan tweet untuk pelatihan, penting untuk melakukan praproses terlebih dahulu untuk menghilangkan gangguan dan membuat standar teks. Berikut adalah langkah-langkah pra-pemrosesan yang umum:

  • Konversi ke huruf kecil: Ubah semua tweet menjadi huruf kecil. Langkah ini memastikan bahwa model memperlakukan kata-kata dengan kasus berbeda sebagai hal yang sama.
  • Hapus tanda baca: Hapus tanda baca atau karakter khusus apa pun dari tweet. Tanda baca tidak memberikan kontribusi banyak terhadap analisis sentimen dan dapat dihilangkan dengan aman.
  • Hapus kata-kata penghenti: Kata-kata penghenti adalah kata-kata umum seperti “itu”, “adalah”, “dan”, dll., yang tidak membawa banyak sentimen. Hapus kata-kata ini dari tweet karena dapat menimbulkan gangguan pada model.
  • Stemming atau lemmatisasi: Lakukan stemming atau lemmatisasi untuk mereduksi kata ke bentuk dasarnya. Stemming mereduksi sebuah kata ke bentuk akarnya dengan menghilangkan sufiks, sedangkan lemmatisasi membawa kata ke bentuk kamusnya. Langkah ini membantu mengurangi jumlah kata unik dan meningkatkan performa model.
  • Tokenisasi: Membagi kalimat menjadi kata-kata individual. Ini memungkinkan Anda menganalisis setiap kata secara terpisah dan membuat tabel jumlah kata nanti.

Buat fungsi bernama preprocess_tweet yang menjalankan setiap langkah pra-pemrosesan secara berurutan.

def preprocess_tweet(tweet):
    # Convert the tweet to lowercase
    tweet = tweet.lower()
    
    # Remove punctuation from the tweet using translation
    tweet = tweet.translate(str.maketrans("", "", string.punctuation))
    
    # Tokenize the tweet into individual words
    tokens = nltk.word_tokenize(tweet)
    
    # Initialize a Porter stemmer for word stemming
    stemmer = PorterStemmer()
    
    # Get a set of English stopwords from NLTK
    stopwords_set = set(stopwords.words("english"))
    
    # Apply stemming to each token and filter out stopwords
    tokens = [stemmer.stem(token) for token in tokens if token not in stopwords_set]
    
    # Return the preprocessed tokens
    return tokens

3. Buat tabel jumlah kata: Buatlah tabel yang menunjukkan kemunculan setiap kata dalam tweet positif dan negatif. Tabel ini sering disebut tabel jumlah kata atau tabel frekuensi istilah, yang akan digunakan untuk menghitung probabilitas kemungkinan pada algoritma Naive Bayes. Untuk setiap tweet, hitung frekuensi setiap kata unik dan catatlah. Tabel tersebut harus menunjukkan berapa kali setiap kata muncul di tweet positif dan negatif.

from collections import defaultdict

def calculate_word_counts(tweets):
    # Initialize a defaultdict to store word counts, defaulting to 0 for unseen words
    word_count = defaultdict(int)
    
    # Iterate through each tweet in the given list of tweets
    for tweet in tweets:
        # Tokenize and preprocess the tweet using the preprocess_tweet function
        tokens = preprocess_tweet(tweet)
        
        # Iterate through each token in the preprocessed tokens
        for token in tokens:
            # Increment the count for the current token in the word_count dictionary
            word_count[token] += 1
    
    # Return the word_count dictionary containing word frequencies
    return word_count

# Calculate word counts for tweets with positive sentiment
word_count_positive = calculate_word_counts(train_df[train_df['sentiment'] == 'positive']['text'])

# Calculate word counts for tweets with negative sentiment
word_count_negative = calculate_word_counts(train_df[train_df['sentiment'] == 'negative']['text'])

# Calculate word counts for tweets with neutral sentiment
word_count_neutral = calculate_word_counts(train_df[train_df['sentiment'] == 'neutral']['text'])

4. Hitung kemungkinan setiap kelas dengan pemulusan Laplacian: Hitung probabilitas kemungkinan setiap kelas (positif, negatif, dan netral) menggunakan tabel jumlah kata. Untuk menghindari probabilitas nol untuk kata-kata yang hanya muncul di satu kelas selama pengujian, terapkan pemulusan Laplacian. Pemulusan Laplacian menambahkan konstanta kecil (biasanya 1) pada pembilang dan mengalikan penyebutnya dengan faktor jumlah kata unik dalam kumpulan data. Hal ini memastikan bahwa setiap kata yang ditemukan selama pengujian, meskipun tidak terlihat dalam pelatihan, memiliki probabilitas bukan nol.

def calculate_likelihood(word_count, total_words, laplacian_smoothing=1):
    # Create an empty dictionary to store the likelihood values
    likelihood = {}
    
    # Get the number of unique words in the vocabulary
    vocabulary_size = len(word_count)

    # Iterate through each word and its corresponding count in the word_count dictionary
    for word, count in word_count.items():
        # Calculate the likelihood using Laplacian smoothing formula
        # Laplacian smoothing is used to handle unseen words in training data
        # The formula is (count + smoothing) / (total_words + smoothing * vocabulary_size)
        likelihood[word] = (count + laplacian_smoothing) / (total_words + laplacian_smoothing * vocabulary_size)

    # Return the calculated likelihood dictionary
    return likelihood

5. Perhitungan Log Probabilitas Sebelumnya:Log Probabilitas Sebelumnya dalam analisis sentimen adalah ekspresi logaritmik yang menunjukkan kemungkinan menemukan sentimen tertentu dalam data teks. Hal ini penting untuk model seperti Naive Bayes, karena membantu klasifikasi sentimen dengan mempertimbangkan distribusi sentimen. Dihitung dengan membagi jumlah teks spesifik sentimen dengan total teks dan menerapkan logaritma, hal ini memandu prediksi sentimen yang akurat berdasarkan sentimen umum.

import math

def calculate_log_prior(sentiment, data):
    # Calculate the natural logarithm of the ratio of tweets with the specified sentiment to the total number of tweets
    log_prior = math.log(len(data[data['sentiment'] == sentiment]) / len(data))
    
    # Return the calculated log prior
    return log_prior

# Calculate the log prior for tweets with positive sentiment
log_prior_positive = calculate_log_prior('positive', df)

# Calculate the log prior for tweets with negative sentiment
log_prior_negative = calculate_log_prior('negative', df)

# Calculate the log prior for tweets with neutral sentiment
log_prior_neutral = calculate_log_prior('neutral', df)

6. Ambil logaritma kemungkinan: Untuk menghindari masalah kekurangan arus saat mengalikan probabilitas, praktik umum adalah mengambil logaritma probabilitas kemungkinan. Logaritma membantu mengubah hasil kali probabilitas menjadi jumlah, sehingga menyederhanakan penghitungan dan meningkatkan akurasi komputasi.

# Create a dictionary of log-likelihood values for positive sentiment
log_likelihood_positive = {word: math.log(prob) for word, prob in likelihood_positive.items()}

# Create a dictionary of log-likelihood values for negative sentiment
log_likelihood_negative = {word: math.log(prob) for word, prob in likelihood_negative.items()}

# Create a dictionary of log-likelihood values for neutral sentiment
log_likelihood_neutral = {word: math.log(prob) for word, prob in likelihood_neutral.items()}

7. Hitung skor sentimen: classify_tweet_with_scoresmengambil tweet yang sudah diproses,nilai log kemungkinan, dan log sebelumnya sebagai masukan dan menghitung skor sentimen untuk setiap kategori. Kemudian memprediksi sentimen berdasarkan skor tertinggi dan mengembalikan prediksi beserta skor sentimen individu. Pendekatan ini sering digunakan dalam tugas analisis sentimen untuk mengklasifikasikan teks berdasarkan skor yang dihitung.

def classify_tweet_with_scores(tweet, log_likelihood_positive, log_likelihood_negative, log_likelihood_neutral,
                               log_prior_positive, log_prior_negative, log_prior_neutral):
    # Tokenize and preprocess the input tweet
    tokens = preprocess_tweet(tweet)

    # Calculate the log scores for each sentiment category
    log_score_positive = log_prior_positive + sum([log_likelihood_positive.get(token, 0) for token in tokens])
    log_score_negative = log_prior_negative + sum([log_likelihood_negative.get(token, 0) for token in tokens])
    log_score_neutral = log_prior_neutral + sum([log_likelihood_neutral.get(token, 0) for token in tokens])

    # Store the sentiment scores in a dictionary
    sentiment_scores = {
        'positive': log_score_positive,
        'negative': log_score_negative,
        'neutral': log_score_neutral
    }

    # Determine the predicted sentiment based on the highest sentiment score
    predicted_sentiment = max(sentiment_scores, key=sentiment_scores.get)
    
    # Return the predicted sentiment and the sentiment scores
    return predicted_sentiment, sentiment_scores

8. Membuat Aplikasi Streamlit:

  • Bangun aplikasi web Streamlit untuk interaksi pengguna.
  • Menggabungkan input teks, klasifikasi sentimen, dan tampilan skor sentimen.
  • Menampilkan gambar khusus sentimen berdasarkan prediksi sentimen.

Kesimpulan

Analisis Sentimen dengan algoritma Naive Bayes adalah pendekatan yang ampuh, menggunakan analisis probabilitas dan linguistik untuk mengkategorikan sentimen teks sebagai positif, negatif, atau netral. Dengan melakukan pra-pemrosesan teks, menghitung log prior, dan memperoleh kemungkinan log, metode ini mengukur sentimen, sehingga memandu klasifikasi yang akurat. Kemampuan beradaptasinya di seluruh domain dan pustaka NLTK Python membuatnya dapat diakses untuk beragam aplikasi. Naive Bayes memperkaya pengambilan keputusan, menawarkan wawasan tentang kepuasan pelanggan, persepsi merek, dan tren, yang penting di era data tekstual yang melimpah.

Silakan akses repositori GitHub saya, di mana Anda dapat menemukan implementasi Analisis Sentimen yang komprehensif menggunakan Algoritma Naive Bayes. Repositori ini berisi kode lengkap dan sumber daya yang terkait dengan proyek.