TIF_E41202489/Analisis Sentiment Program Merdeka Belajar Kampus Merdeka Pada Pengguna Twitter Menggunakan Metode Naive Bayes.py

#!/usr/bin/env python
# coding: utf-8

# In[27]:


import pandas as pd
import numpy as np
import string
import re
import requests
import warnings

warnings.filterwarnings("ignore")


# In[28]:


# Menampilkan semua baris dan kolom
pd.set_option('display.max_rows', None)
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)
pd.set_option('display.max_colwidth', None)


# In[29]:


# Membaca data dari file CSV
data = pd.read_csv('D:/Kuliah/SKRIPSI/testing/datambkm/mbkmdata.csv', sep=';')

# Mengubah tipe data kolom label menjadi integer
data['Label'] = data['Label'].astype(int)

data.head()


# In[30]:


# Mengetahuli kolom dan tipe data
data.dtypes


# In[31]:


# Mengetahui jumlah baris data dan kolom
data.shape


# In[32]:


# Mengetahui isi data secara rinci
print(data.info())
print(data['Label'].value_counts())


# In[33]:


# Mengetahui jika ada kolom yang kosong
# data = data.dropna() code untuk menghilangkan jika ada yang kosong
data.isnull().sum()


# In[34]:


# Mengecek data duplikat atau data yang sama
data.duplicated().sum()


# In[35]:


# Menghapus kolom datetime dan username
data = data.drop(columns=['created_at', 'id_str', 'username', 'tweet_url'])

data.head()


# In[36]:


#CLEANSING

def clean_text(text):
    # Menghapus URL
    text = re.sub(r'http\S+', '', text)
    
    # Menghapus mention (@username)
    text = re.sub(r'@\w+', '', text)
    
    # Menghapus hashtag
    text = re.sub(r'#\w+', '', text)
    
    # Menghapus emotikon
    text = re.sub(r'[\U00010000-\U0010ffff]', '', text)
    
    # Menghapus karakter khusus (kecuali huruf dan angka)
    text = re.sub(r'[^\w\s]', '', text)
    
    # Menghapus spasi ganda
    text = re.sub(r'\s+', ' ', text).strip()
    
    # Menghapus angka (opsional)
    text = re.sub(r'\d+', '', text)
    
    return text

# Membersihkan teks dalam kolom 'full_text'
data['clean_text'] = data['full_text'].apply(clean_text)

data.head()


# In[37]:


# CASEFOLDING

data['clean_text'] = data['clean_text'].str.lower()

data.head()


# In[38]:


#NORMALISASI

# Membaca kamus normalisasi dari file CSV
normalized_word = pd.read_csv("normalisasi.csv", encoding="latin1")
normalized_word_dict = {}
for index, row in normalized_word.iterrows():
    if row[0] not in normalized_word_dict:
        normalized_word_dict[row[0]] = row[1]

# Fungsi untuk menerapkan normalisasi ke teks
def normalized_term(document):
    return ' '.join(normalized_word_dict.get(term.lower(), term) for term in document.split())

# Menerapkan normalisasi ke kolom 'full_text' dan menyimpan hasilnya di kolom 'normalisasi'
data['normalisasi'] = data['clean_text'].apply(normalized_term)

# Memindahkan kolom label ke paling belakang
label_column = data.pop('Label')
data['Label'] = label_column

data.head()


# In[39]:


#STOPWORD

# Membaca daftar stopwords dari file "stopwords.txt"
with open("stopwords.txt", "r") as file:
    stopwords = file.readlines()
stopwords = {word.strip() for word in stopwords}  # Mengubah list menjadi set

# Menambahkan stopwords tambahan
additional_stopwords = {"kalo", "bisa2", "kayaknya", "gue", "sih", "matkul2", "lnkdn", "fafifuwasweswos", "nder", "braw", 
                        "ges", "nya", "an", "shg", "ya", "guys", "wkwkwk", "gua", "gais", "sender", "se7", "hahahahaft", "heeii",
                       "harianmingguan2", "mingguanbulanan", "sayang", "entar"}
stopwords |= additional_stopwords  # Menggunakan operator | untuk menggabungkan set

# Fungsi untuk menghapus stopwords dari teks
def remove_stopwords(text):
    words = text.split()  # Memisahkan teks menjadi kata-kata
    filtered_words = [word for word in words if word.lower() not in stopwords]  # Memfilter kata-kata yang bukan stopwords
    return ' '.join(filtered_words)  # Menggabungkan kata-kata yang tersisa menjadi teks kembali

# Fungsi untuk menghapus angka dari teks
def remove_numbers(text):
    words = text.split()  # Memisahkan teks menjadi kata-kata
    filtered_words = [word for word in words if not word.isdigit()]  # Memfilter kata-kata yang bukan angka
    return ' '.join(filtered_words)  # Menggabungkan kata-kata yang tersisa menjadi teks kembali

# Menghapus stopwords dari kolom 'full_text'
data['stopwords'] = data['normalisasi'].apply(remove_stopwords)

# Menghapus angka dari kolom 'stopwords'
data['stopwords'] = data['stopwords'].apply(remove_numbers)

# Memindahkan kolom label ke paling belakang
label_column = data.pop('Label')
data['Label'] = label_column

data.head()


# In[40]:


#STEMMING

from Sastrawi.Stemmer.StemmerFactory import StemmerFactory

# Buat objek stemmer
factory = StemmerFactory()
stemmer = factory.create_stemmer()

# Fungsi untuk melakukan stemming pada teks
def stemmed_term(text):
    # Memecah teks menjadi kata-kata
    words = text.split()
    # Melakukan stemming pada setiap kata
    stemmed_words = [stemmer.stem(word) for word in words]
    # Menggabungkan kata-kata yang telah distem
    return ' '.join(stemmed_words)

# Menerapkan stemming ke kolom 'stopwords' atau 'normalisasi'
data['stemmed'] = data['stopwords'].apply(stemmed_term)

# Memindahkan kolom label ke paling belakang
label_column = data.pop('Label')
data['Label'] = label_column

data.head()


# In[41]:


from nltk.tokenize import word_tokenize

# Fungsi untuk melakukan tokenisasi pada teks
def tokenize_text(text):
    # Melakukan tokenisasi pada teks menggunakan nltk
    tokens = word_tokenize(text)
    return tokens

# Menerapkan tokenisasi ke kolom 'stemmed' dan menyimpan hasilnya di kolom 'tokens'
data['tokens'] = data['stemmed'].apply(tokenize_text)

# Memindahkan kolom label ke paling belakang
label_column = data.pop('Label')
data['Label'] = label_column

data.head()


# In[42]:


#PERHITUNGAN TF

# Import library Pandas
import pandas as pd

# Definisikan fungsi untuk menghitung TF
def calc_TF(document):
    TF_dict = {}
    for term in document:
        if term in TF_dict:
            TF_dict[term] += 1
        else:
            TF_dict[term] = 1
    
    # Menghitung nilai TF pada tiap kata
    total_terms = len(document)
    for term in TF_dict:
        TF_dict[term] = TF_dict[term] / total_terms
    
    return TF_dict

# Menghitung TF untuk setiap dokumen dan menyimpannya dalam kolom 'TF_dict'
data['TF_dict'] = data['stemmed'].apply(lambda x: calc_TF(x.split()))

# Membuat list kosong untuk menyimpan hasil perhitungan TF
tf_results = []

# Memasukkan hasil perhitungan TF ke dalam list
for idx, row in data.iterrows():
    for term, value in row['TF_dict'].items():
        tf_results.append({'Term': term, 'TF': value})

# Membuat DataFrame dari list hasil perhitungan TF
tf_results_df = pd.DataFrame(tf_results)

# Menyimpan DataFrame ke dalam file Excel
#output_file = 'D:/Kuliah/SKRIPSI/testing/tf-idf/tfcoba1.xlsx'
#tf_results_df.to_excel(output_file, index=False)

#print(f"Hasil perhitungan TF telah disimpan ke dalam file: {output_file}")

# Mendapatkan jumlah data yang telah dihitung TF
num_documents = len(data)

# Menampilkan tabel hasil perhitungan TF
print(f"Hasil perhitungan TF : {num_documents} data")


# In[43]:


import pandas as pd

# Definisikan fungsi untuk menghitung DF
def hitung_DF(kamus_TF):
    frekuensi_DF = {}
    # Inisialisasi set untuk menyimpan dokumen unik yang mengandung term
    dokumen_per_term = {}
    
    # Menelusuri kamus TF dari setiap dokumen dan mengisi frekuensi_DF dan dokumen_per_term
    for dokumen_idx, dokumen in enumerate(kamus_TF):
        # Menghapus duplikasi term dalam dokumen
        dokumen_set = set(dokumen)
        for term in dokumen_set:
            if term in frekuensi_DF:
                frekuensi_DF[term] += 1
            else:
                frekuensi_DF[term] = 1
            
            if term in dokumen_per_term:
                dokumen_per_term[term].add(dokumen_idx)
            else:
                dokumen_per_term[term] = {dokumen_idx}
    
    return frekuensi_DF, dokumen_per_term

# Menghitung DF untuk setiap term dalam kolom 'TF_dict'
DF, dokumen_per_term = hitung_DF(data["TF_dict"])

# Konversi kamus DF ke dalam DataFrame
df_df = pd.DataFrame(list(DF.items()), columns=['Term', 'DF'])

# Menyimpan DataFrame ke dalam file Excel
#output_file = 'D:/Kuliah/SKRIPSI/testing/tf-idf/dfcoba2.xlsx'
#df_df.to_excel(output_file, index=False)

# Mendapatkan jumlah data yang telah dihitung DF (jumlah dokumen)
num_documents = len(data)  # Jumlah baris dalam DataFrame data

# Menampilkan tabel hasil perhitungan DF
print(f"Hasil perhitungan DF untuk {num_documents} data")


# In[44]:


# Definisikan fungsi untuk menghitung DF
def hitung_DF(kamus_TF):
    frekuensi_DF = {}
    # Inisialisasi set untuk menyimpan dokumen unik yang mengandung term
    dokumen_per_term = {}
    
    # Menelusuri kamus TF dari setiap dokumen dan mengisi frekuensi_DF dan dokumen_per_term
    for dokumen_idx, dokumen in enumerate(kamus_TF):
        # Menghapus duplikasi term dalam dokumen
        dokumen_set = set(dokumen)
        for term in dokumen_set:
            if term in frekuensi_DF:
                frekuensi_DF[term] += 1
            else:
                frekuensi_DF[term] = 1
            
            if term in dokumen_per_term:
                dokumen_per_term[term].add(dokumen_idx)
            else:
                dokumen_per_term[term] = {dokumen_idx}
    
    return frekuensi_DF, dokumen_per_term

# Definisikan fungsi untuk menghitung IDF
def calc_IDF(n_document, DF):
    IDF_Dict = {}
    for term in DF:
        IDF_Dict[term] = np.log2(n_document / (DF[term] + 1))
    return IDF_Dict

# Menghitung DF untuk setiap term dalam kolom 'TF_dict'
DF, dokumen_per_term = hitung_DF(data["TF_dict"])

# Jumlah dokumen
n_document = len(data)

# Menghitung IDF
IDF = calc_IDF(n_document, DF)

# Membuat DataFrame untuk menyimpan hasil perhitungan IDF
idf_df = pd.DataFrame(IDF.items(), columns=['Term', 'IDF'])

# Menyimpan DataFrame ke dalam file Excel
#output_file = 'D:/Kuliah/SKRIPSI/testing/tf-idf/idf12.xlsx'
#idf_df.to_excel(output_file, index=False)

# Mendapatkan jumlah term yang telah dihitung IDF
num_documents = len(data)

# Menampilkan tabel hasil perhitungan IDF
print(f"Hasil perhitungan IDF : {num_documents} data")


# In[45]:


import pandas as pd
import numpy as np

# Definisikan fungsi untuk menghitung DF
def hitung_DF(kamus_TF):
    frekuensi_DF = {}
    # Inisialisasi set untuk menyimpan dokumen unik yang mengandung term
    dokumen_per_term = {}
    
    # Menelusuri kamus TF dari setiap dokumen dan mengisi frekuensi_DF dan dokumen_per_term
    for dokumen_idx, dokumen in enumerate(kamus_TF):
        # Menghapus duplikasi term dalam dokumen
        dokumen_set = set(dokumen)
        for term in dokumen_set:
            if term in frekuensi_DF:
                frekuensi_DF[term] += 1
            else:
                frekuensi_DF[term] = 1
            
            if term in dokumen_per_term:
                dokumen_per_term[term].add(dokumen_idx)
            else:
                dokumen_per_term[term] = {dokumen_idx}
    
    return frekuensi_DF, dokumen_per_term

# Definisikan fungsi untuk menghitung IDF
def calc_IDF(n_document, DF):
    IDF_Dict = {}
    for term in DF:
        IDF_Dict[term] = np.log2(n_document / (DF[term] + 1))
    return IDF_Dict

# Definisikan fungsi untuk menghitung TF-IDF
def calc_TF_IDF(TF, IDF):
    TF_IDF_Dict = {}
    # Untuk setiap term dalam TF
    for term in TF:
        # Mengalikan nilai TF dengan nilai IDF
        TF_IDF_Dict[term] = TF[term] * IDF[term]
    return TF_IDF_Dict

# Menghitung DF untuk setiap term dalam kolom 'TF_dict'
DF, dokumen_per_term = hitung_DF(data["TF_dict"])

# Jumlah dokumen
n_document = len(data)

# Menghitung IDF
IDF = calc_IDF(n_document, DF)

# Menerapkan fungsi calc_TF_IDF ke setiap dokumen dalam DataFrame
data['TF-IDF_dict'] = data['TF_dict'].apply(lambda x: calc_TF_IDF(x, IDF))

# Membuat list kosong untuk menyimpan hasil perhitungan TF-IDF
tf_idf_results = []

# Memasukkan hasil perhitungan TF-IDF ke dalam list
for idx, row in data.iterrows():
    for term, value in row['TF-IDF_dict'].items():
        tf_idf_results.append({'Term': term, 'TF-IDF': value})

# Membuat DataFrame dari list hasil perhitungan TF-IDF
tf_idf_results_df = pd.DataFrame(tf_idf_results)

# Menyimpan DataFrame ke dalam file Excel
#output_file = 'D:/Kuliah/SKRIPSI/testing/tf-idf/tf-idfcoba.xlsx'
#tf_idf_results_df.to_excel(output_file, index=False)

# Mendapatkan jumlah term yang telah dihitung TF-IDF
num_terms = tf_idf_results_df.shape[0]

# Menampilkan tabel hasil perhitungan TF-IDF
print(f"Hasil perhitungan TF-IDF untuk {num_terms} term, dari {num_documents} data")


# In[46]:


# Membuat fungsi untuk menghitung kemunculan frekuensi term positif, negatif, dan netral
def hitung_frekuensi_sentimen(data, term):
    frekuensi_positif = 0
    frekuensi_negatif = 0
    frekuensi_netral = 0
    
    # Menelusuri setiap baris data
    for idx, row in data.iterrows():
        # Jika term ada dalam TF-IDF dict dan memiliki nilai TF-IDF yang lebih besar dari 0
        if term in row['TF-IDF_dict'] and row['TF-IDF_dict'][term] > 0:
            # Jika label positif, tambahkan ke frekuensi_positif
            if row['Label'] == 1:
                frekuensi_positif += 1
            # Jika label negatif, tambahkan ke frekuensi_negatif
            elif row['Label'] == -1:
                frekuensi_negatif += 1
            # Jika label netral, tambahkan ke frekuensi_netral
            elif row['Label'] == 0:
                frekuensi_netral += 1
    
    return frekuensi_positif, frekuensi_negatif, frekuensi_netral

# Membuat list term yang akan dihitung frekuensi positif, negatif, dan netralnya
list_term = ['program', 'mbkm', 'bagus']

# Membuat list kosong untuk menyimpan hasil perhitungan frekuensi positif, negatif, dan netral
frekuensi_results = []

# Memasukkan hasil perhitungan frekuensi positif, negatif, dan netral ke dalam list
for term in list_term:
    frekuensi_positif, frekuensi_negatif, frekuensi_netral = hitung_frekuensi_sentimen(data, term)
    frekuensi_results.append({'Term': term, 'Positif': frekuensi_positif, 'Negatif': frekuensi_negatif, 'Netral': frekuensi_netral})

# Membuat DataFrame dari list hasil perhitungan frekuensi positif, negatif, dan netral
frekuensi_df = pd.DataFrame(frekuensi_results)

# Menampilkan tabel hasil perhitungan frekuensi positif, negatif, dan netral
print(frekuensi_df)


# In[47]:


from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd

# Misalkan data sudah dalam bentuk DataFrame bernama 'data'
# Definisikan X dan y
X = data['stemmed']
y = data['Label']

# Memisahkan data menjadi data latih dan data uji
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.10, random_state=42)

# Menginisialisasi TF-IDF Vectorizer
tfidf_vectorizer = TfidfVectorizer()

# Melakukan vectorization pada data latih dan uji
X_train_tfidf = tfidf_vectorizer.fit_transform(x_train)
X_test_tfidf = tfidf_vectorizer.transform(x_test)

# Tampilkan panjang data latih dan data uji
print("x_train =", len(x_train))
print("x_test =", len(x_test))
print("y_train =", len(y_train))
print("y_test =", len(y_test))

# Membuat DataFrame dari data yang telah dipisah
#train_data = pd.DataFrame({'stemmed': x_train, 'Label': y_train})
#test_data = pd.DataFrame({'stemmed': x_test, 'Label': y_test})

# Menyimpan data ke dalam file Excel
#with pd.ExcelWriter('D:/Kuliah/SKRIPSI/testing/tf-idf/splitdata.xlsx') as writer:
    #train_data.to_excel(writer, sheet_name='Train Data', index=False)
    #test_data.to_excel(writer, sheet_name='Test Data', index=False)


# In[48]:


from collections import Counter

# Menggabungkan teks positif, netral dan negatif berdasarkan label
positif_text = ' '.join(x_train[y_train == 1])
negatif_text = ' '.join(x_train[y_train == -1])
netral_text = ' '.join(x_train[y_train == 0])

# Membagi teks positif, netral dan negatif menjadi term
positif_terms = positif_text.split()
negatif_terms = negatif_text.split()
netral_terms = netral_text.split()

# Menghitung jumlah kemunculan term pada teks positif, netral dan negatif
jumlah_term_positif = len(positif_terms)
jumlah_term_negatif = len(negatif_terms)
jumlah_term_netral = len(netral_terms)

# Menampilkan jumlah term positif, netral dan negatif pada data pelatihan
print("Jumlah term pada dokumen training positif:", jumlah_term_positif)
print("Jumlah term pada dokumen training negatif:", jumlah_term_negatif)
print("Jumlah term pada dokumen training netral:", jumlah_term_netral)


# In[49]:


from collections import Counter

# Menghitung jumlah data positif, netral dan negatif pada data pelatihan
counter_train = Counter(y_train)
jumlah_data_positif_train = counter_train[1]
jumlah_data_negatif_train = counter_train[-1]
jumlah_data_netral_train = counter_train[0]

# Menghitung jumlah data positif, netral dan negatif pada data pengujian
counter_test = Counter(y_test)
jumlah_data_positif_test = counter_test[1]
jumlah_data_negatif_test = counter_test[-1]
jumlah_data_netral_test = counter_test[0]

# Menampilkan jumlah data positif, netral dan negatif pada data pelatihan dan pengujian
print("Jumlah data positif pada data training:", jumlah_data_positif_train)
print("Jumlah data negatif pada data training:", jumlah_data_negatif_train)
print("Jumlah data netral pada data training:", jumlah_data_netral_train)
print("Jumlah data positif pada data testing:", jumlah_data_positif_test)
print("Jumlah data negatif pada data testing:", jumlah_data_negatif_test)
print("Jumlah data netral pada data testing:", jumlah_data_netral_test)


# In[53]:


from sklearn.feature_extraction.text import CountVectorizer

# Inisialisasi CountVectorizer
vectorizer = CountVectorizer()

# Melakukan vectorization pada data latih
x_train_vec = vectorizer.fit_transform(x_train)

# Melakukan vectorization pada data uji
x_test_vec = vectorizer.transform(x_test)

# Menghitung prediksi dari model pada data uji
y_pred = naive_bayes.predict(X_test_tfidf)


# In[54]:


from sklearn.naive_bayes import MultinomialNB

# Inisialisasi model Naive Bayes Classifier
naive_bayes = MultinomialNB()

# Melatih model pada data latih yang telah disesuaikan
naive_bayes.fit(x_train_vec, y_train)


# In[55]:


from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report

# Hitung metrik evaluasi
accuracy = accuracy_score(y_test, y_pred)
classification_rep = classification_report(y_test, y_pred, target_names=['-1', '1','0'])
recall = recall_score(y_test, y_pred, average='weighted')
precision = precision_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')

# Cetak hasil evaluasi
print('Akurasi Model Naive Bayes :', '{:.2f}%'.format(accuracy * 100))
print('Rata-Rata Precision :', '{:.2f}%'.format(precision * 100))
print('Rata-Rata Recall :', '{:.2f}%'.format(recall * 100))
print('Rata-Rata F1-score :', '{:.2f}%'.format(f1 * 100))
print("\nLaporan Klasifikasi :\n", classification_rep)


# In[56]:


from wordcloud import WordCloud
import matplotlib.pyplot as plt

# Ambil data berdasarkan label
neutral_data = data[data['Label'] == 0]
positive_data = data[data['Label'] == 1]
negative_data = data[data['Label'] == -1]

# Gabungkan semua teks menjadi satu teks panjang untuk masing-masing kelompok
all_text_neutral = ' '.join(neutral_data['stemmed'])
all_text_positive = ' '.join(positive_data['stemmed'])
all_text_negative = ' '.join(negative_data['stemmed'])

# Buat set kata-kata unik dari teks positif dan negatif
words_in_positive = set(all_text_positive.split())
words_in_negative = set(all_text_negative.split())

# Filter teks netral untuk hanya memasukkan kata-kata yang tidak ada di teks positif dan negatif
filtered_text_neutral = ' '.join(word for word in all_text_neutral.split() if word not in words_in_positive and word not in words_in_negative)

# Inisialisasi WordCloud dengan parameter collocations=False
wordcloud_neutral = WordCloud(width=800, height=400, background_color='white', collocations=False).generate(filtered_text_neutral)

# Tampilkan WordCloud untuk kata-kata netral
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud_neutral, interpolation='bilinear')
plt.axis('off')
plt.title('WordCloud Kata Netral')
plt.show()


# In[57]:


from wordcloud import WordCloud
import matplotlib.pyplot as plt

# Ambil data berdasarkan label
neutral_data = data[data['Label'] == 0]
positive_data = data[data['Label'] == 1]
negative_data = data[data['Label'] == -1]

# Gabungkan semua teks menjadi satu teks panjang untuk masing-masing kelompok
all_text_neutral = ' '.join(neutral_data['stemmed'])
all_text_positive = ' '.join(positive_data['stemmed'])
all_text_negative = ' '.join(negative_data['stemmed'])

# Buat set kata-kata unik dari teks netral dan negatif
words_in_neutral = set(all_text_neutral.split())
words_in_negative = set(all_text_negative.split())

# Filter teks positif untuk hanya memasukkan kata-kata yang tidak ada di teks netral dan negatif
filtered_text_positive = ' '.join(word for word in all_text_positive.split() if word not in words_in_neutral and word not in words_in_negative)

def green_color_func(word, font_size, position, orientation, random_state=None, **kwargs):
    return "rgb(0, 128, 0)"  # Warna hijau tua 

# Inisialisasi WordCloud dengan parameter collocations=False dan colormap='Greens'
wordcloud_positive = WordCloud(width=800, height=400, background_color='white', color_func=green_color_func, collocations=False).generate(filtered_text_positive)

# Tampilkan WordCloud untuk kata-kata positif
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud_positive, interpolation='bilinear')
plt.axis('off')
plt.title('WordCloud Kata Positif')
plt.show()


# In[58]:


from wordcloud import WordCloud
import matplotlib.pyplot as plt

# Ambil data berdasarkan label
neutral_data = data[data['Label'] == 0]
positive_data = data[data['Label'] == 1]
negative_data = data[data['Label'] == -1]

# Gabungkan semua teks menjadi satu teks panjang untuk masing-masing kelompok
all_text_neutral = ' '.join(neutral_data['stemmed'])
all_text_positive = ' '.join(positive_data['stemmed'])
all_text_negative = ' '.join(negative_data['stemmed'])

# Buat set kata-kata unik dari teks positif dan netral
words_in_positive = set(all_text_positive.split())
words_in_neutral = set(all_text_neutral.split())

# Filter teks negatif untuk hanya memasukkan kata-kata yang tidak ada di teks positif dan netral
filtered_text_negative = ' '.join(word for word in all_text_negative.split() if word not in words_in_positive and word not in words_in_neutral)

def red_color_func(word, font_size, position, orientation, random_state=None, **kwargs):
    return "hsl(0, 100%, 50%)"  # Merah

# Inisialisasi WordCloud dengan parameter collocations=False
wordcloud_negative = WordCloud(width=800, height=400, background_color='white',color_func=red_color_func, collocations=False).generate(filtered_text_negative)

# Tampilkan WordCloud untuk kata-kata negatif
plt.figure(figsize=(10, 6))
plt.imshow(wordcloud_negative, interpolation='bilinear')
plt.axis('off')
plt.title('WordCloud Kata Negatif')
plt.show()


# In[59]:


import matplotlib.pyplot as plt

# Data jumlah dokumen untuk setiap kelas
class_counts = data['Label'].value_counts()

# Label untuk setiap kelas dengan jumlah data
labels = [f'{label} ({count})' for label, count in zip(['Netral','Positif', 'Negatif'], class_counts)]

# Warna untuk setiap kelas
colors = ['orange', 'blue', 'red']

# Membuat pie chart
plt.pie(class_counts, labels=labels, colors=colors, autopct='%1.1f%%', startangle=140)

# Menambahkan judul
plt.title('Persentase Kelas Sentimen')

# Menampilkan pie chart
plt.show()


# In[70]:


from sklearn.feature_extraction.text import CountVectorizer

# Misalkan vectorizer dan naive_bayes sudah diinisialisasi sebelumnya
# Anda perlu menyesuaikan dengan inisialisasi yang telah Anda lakukan sebelumnya

new_text = input("\nMasukkan teks baru: ")  # Mengambil input teks baru dari pengguna
new_text_vec = vectorizer.transform([new_text])  # Mengubah teks menjadi vektor fitur menggunakan objek vectorizer yang telah dibuat sebelumnya
predicted_sentimen = naive_bayes.predict(new_text_vec)  # Memprediksi sentimen teks menggunakan model naive bayes yang telah dilatih

# Mengubah hasil prediksi menjadi label sentimen yang sesuai
if predicted_sentimen[0] == 1:
    sentiment_label = "Positif"
elif predicted_sentimen[0] == 0:
    sentiment_label = "Netral"
else:
    sentiment_label = "Negatif"

# Mencetak hasil analisis sentimen
print("Hasil Analisis Sentimen untuk Teks Baru:", sentiment_label)


# In[ ]: