823 lines
24 KiB
Python
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[ ]:
|
|
|
|
|
|
|
|
|