TIF_E41202489/Analisis Sentiment Program ...

823 lines
24 KiB
Python

#!/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[ ]: