Implementing a Sentiment Classification Model with BERT for IMDb Reviews on Boruto: Naruto Next Generation
Boruto: Naruto Next Generation adalah serial anime yang merupakan sekuel dari anime populer Naruto. Cerita ini berfokus pada petualangan Boruto Uzumaki, putra Naruto Uzumaki, yang kini telah menjadi Hokage Ketujuh di desa Konoha. Serial ini mengikuti perjalanan Boruto dan teman-temannya saat mereka menghadapi tantangan baru, mengembangkan kemampuan ninja mereka, dan berusaha membuktikan diri di dunia yang terus berubah. Boruto: Naruto Next Generation mendapatkan banyak ulasan yang menarik untuk dilakukan analisis sentimen terkait alur cerita, efek visual, karakter, dsb.
Sentiment Analysis dengan BERT
Sentiment analysis, atau analisis sentimen, adalah proses mengidentifikasi dan mengkategorikan opini yang dinyatakan dalam teks untuk menentukan apakah sikap penulis terhadap topik tertentu positif, negatif, atau netral. Dalam proyek ini, kita akan menggunakan model BERT (Bidirectional Encoder Representations from Transformers) untuk melakukan sentiment analysis pada ulasan IMDb untuk film Boruto: Naruto Next Generation.
Mengapa Menggunakan BERT?
BERT adalah model bahasa yang kuat yang telah dilatih pada sejumlah besar teks dan memiliki pemahaman yang mendalam tentang konteks. Ini memungkinkan BERT untuk memahami dan menginterpretasikan makna dari kata-kata dalam sebuah kalimat dengan lebih baik dibandingkan dengan model-model sebelumnya. Dengan menggunakan BERT, kita dapat meningkatkan akurasi dalam mendeteksi sentimen dalam ulasan.
Langkah-langkah dalam Sentiment Analysis dengan BERT
Langkah untuk melakukan analisis sentimen dengan BERT adalah Crawling Data, Preprocessing Data, Labeling Data, Implementing Transformers, Evaluation. Berikut adalah berbagai library yang akan digunakan:
import nltk
import requests
from bs4 import BeautifulSoup
import string
from nltk.corpus import stopwords
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv1D, MaxPooling1D, Dropout, Flatten
import json
import time
from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from datasets import Dataset, DatasetDict, load_dataset
import torch
from textblob import TextBlob
from sklearn.preprocessing import LabelEncoderPastikan anda sudah menginstal library yang diperlukan, seperti nltk, requests, BeautifulSoup, pandas, sklearn, tensorflow, dan transformers. Anda dapat menginstalnya dengan menggunakan perintah:
pip install <library_name>Crawling Data
Langkah pertama yang dilakukan adalah crawling data ulasan film Boruto: Naruto Next Generation dari situs IMDb. Crawling adalah proses otomatisasi pengumpulan data dari web dengan mengirim permintaan HTTP ke halaman web dan mem-parsing konten yang diambil untuk mengekstrak informasi yang relevan. Saya menggunakan requests untuk mengirim permintaan HTTP dan BeautifulSoup dari pustaka bs4 untuk mem-parsing HTML dari halaman ulasan IMDb. Dengan teknik ini, saya dapat mengumpulkan teks ulasan pengguna yang kemudian digunakan sebagai data untuk melatih model klasifikasi sentimen berbasis BERT.
# Crawling Ulasan dari IMDb
url = "https://www.imdb.com/title/tt6342474/reviews?sort=submissionDate&dir=desc&ratingFilter=0"
headers = {'User-Agent': 'Mozilla/5.0'}
response = requests.get(url, headers=headers)
if response.status_code == 200:
page_content = response.content
soup = BeautifulSoup(page_content, 'html.parser')
reviews = soup.find_all('div', class_='text show-more__control')
review_texts = [review.get_text() for review in reviews]
else:
print("Failed to retrieve the webpage.")
review_texts = []
Preprocessing Data
Setelah mengumpulkan ulasan dari IMDb, langkah selanjutnya adalah preprocessing data. Preprocessing adalah tahap penting dalam analisis teks yang bertujuan untuk membersihkan dan menyiapkan data mentah agar siap digunakan dalam pelatihan model. Saya menggunakan beberapa teknik preprocessing untuk meningkatkan kualitas data ulasan. Pertama, saya mengunduh daftar stopwords menggunakan pustaka NLTK. Kemudian, saya mendefinisikan fungsi-fungsi untuk menghapus tanda baca (remove_punctuation), mengubah teks menjadi huruf kecil (to_lowercase), dan menghapus stopwords (remove_stopwords). Semua fungsi ini diterapkan pada setiap ulasan melalui fungsi preprocess_reviews. Hasilnya adalah teks ulasan yang lebih bersih dan siap untuk digunakan dalam pelatihan model klasifikasi sentimen.
# Download stopwords
nltk.download('stopwords')
# Membuat Fungsi untuk Preprocessing
def remove_punctuation(text):
return text.translate(str.maketrans('', '', string.punctuation))
def to_lowercase(text):
return text.lower()
def remove_stopwords(text):
stop_words = set(stopwords.words('english'))
return ' '.join(word for word in text.split() if word not in stop_words)
def preprocess_reviews(reviews):
preprocessed_reviews = []
for review in reviews:
review = remove_punctuation(review)
review = to_lowercase(review)
review = remove_stopwords(review)
preprocessed_reviews.append(review)
return preprocessed_reviews
# Menerapkan Preprocessing
preprocessed_reviews = preprocess_reviews(review_texts)
# Menampilkan Hasil Preprocessing
for i, review in enumerate(preprocessed_reviews):
print(f"Preprocessed Review {i+1}: {review}")
Labeling Data
Setelah preprocessing, langkah berikutnya adalah pelabelan data. Pelabelan data adalah proses memberikan label sentimen pada teks ulasan untuk menentukan apakah sentimen tersebut positif, negatif, atau netral. Saya menggunakan pustaka TextBlob untuk melakukan analisis sentimen. Fungsi label_sentiment menganalisis polaritas sentimen dari setiap ulasan dan memberikan label ‘positive’, ‘negative’, atau ‘neutral’ berdasarkan nilai polaritas tersebut. Hasil pelabelan ini kemudian dikonversi menjadi DataFrame menggunakan pandas dan disimpan ke dalam file CSV dengan nama labeled_reviews.csv. Langkah ini menghasilkan dataset yang berlabel yang siap digunakan untuk pelatihan model klasifikasi sentimen.
# Fungsi untuk memberi label pada sentimen
def label_sentiment(text):
analysis = TextBlob(text)
if analysis.sentiment.polarity > 0:
return 'positive'
elif analysis.sentiment.polarity < 0:
return 'negative'
else:
return 'neutral'
# Terapkan pelabelan sentimen
labeled_reviews = [(review, label_sentiment(review)) for review in preprocessed_reviews]
# Konversi ke DataFrame dan simpan
df_labeled_reviews = pd.DataFrame(labeled_reviews, columns=['text', 'label'])
df_labeled_reviews.to_csv('labeled_reviews.csv', index=False)
df_labeled_reviews
Implementing Transformers
Setelah melalui tahap preprocessing dan pelabelan data, langkah berikutnya adalah menerapkan model transformer untuk analisis sentimen menggunakan BERT (Bidirectional Encoder Representations from Transformers). Pertama, dataset yang berisi ulasan berlabel dimuat dan labelnya dikonversi menjadi format numerik menggunakan LabelEncoder untuk memudahkan pelatihan model. Data kemudian diacak dan dibagi menjadi subset pelatihan dan pengujian. Dataset yang telah dibagi diubah menjadi format Dataset dari library datasets, yang kompatibel dengan model-transformer. Tokenisasi teks dilakukan menggunakan tokenizer BERT, yaitu BertTokenizer, yang mempersiapkan data untuk dimasukkan ke dalam model dengan padding dan pemangkasan teks agar sesuai dengan panjang maksimum yang ditentukan. Model BERT untuk klasifikasi urutan, BertForSequenceClassification, diunduh dan diinisialisasi dengan jumlah label yang sesuai dengan dataset.
# Muat dataset Anda
data = pd.read_csv('labeled_reviews.csv') # Ganti dengan path dataset Anda
# Konversi label ke numerik
label_encoder = LabelEncoder()
data['label'] = label_encoder.fit_transform(data['label'])
def rename_label_column(dataset):
dataset = dataset.rename_column("label", "labels")
return dataset
# Split dataset
split_data = data.sample(frac=1, random_state=42) # Acak data
split_data_train = split_data[:int(0.8*len(split_data))]
split_data_test = split_data[int(0.8*len(split_data)):]
# Convert DataFrame to Dataset
train_dataset = Dataset.from_pandas(split_data_train)
test_dataset = Dataset.from_pandas(split_data_test)
# Load tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-large-uncased')
# Tokenisasi dataset
def tokenize_function(examples):
return tokenizer(examples['text'], padding='max_length', truncation=True)
tokenized_train_dataset = train_dataset.map(tokenize_function, batched=True)
tokenized_test_dataset = test_dataset.map(tokenize_function, batched=True)Selanjutnya, saya mendefinisikan fungsi compute_metrics untuk mengevaluasi akurasi dan skor F1 dari model. Proses pelatihan dikonfigurasi menggunakan TrainingArguments, termasuk pengaturan untuk jumlah epoch, ukuran batch, dan direktori penyimpanan hasil pelatihan. Dengan menggunakan Trainer, model dilatih pada dataset tokenisasi dan hasilnya disimpan untuk evaluasi lebih lanjut. Metodologi ini memungkinkan penerapan model transformer yang kuat untuk tugas klasifikasi teks, memanfaatkan kekuatan BERT dalam memahami konteks dan makna dari teks ulasan film Boruto: Naruto Next Generation.
# Muat model
model = BertForSequenceClassification.from_pretrained('bert-large-uncased', num_labels=len(data['label'].unique()))
# Definisikan fungsi compute_metrics
def compute_metrics(eval_pred):
logits, labels = eval_pred
predictions = logits.argmax(axis=-1)
accuracy = accuracy_score(labels, predictions)
f1 = f1_score(labels, predictions, average='weighted')
return {'eval_accuracy': accuracy, 'eval_f1': f1}
# Argumen pelatihan
training_args = TrainingArguments(
output_dir='./results',
evaluation_strategy='epoch',
per_device_train_batch_size=8,
per_device_eval_batch_size=8,
num_train_epochs=3,
weight_decay=0.01,
logging_dir='./logs',
)
# Inisialisasi Trainer dengan compute_metrics
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_train_dataset,
eval_dataset=tokenized_test_dataset,
compute_metrics=compute_metrics
)
# Mulai pelatihan
trainer.train()
Evaluation
Setelah proses pelatihan selesai, model dievaluasi untuk mengukur kinerjanya pada data pengujian menggunakan metode evaluate dari Trainer. Evaluasi ini menghasilkan beberapa metrik yang memberikan gambaran tentang efektivitas model dalam memprediksi label yang benar. Hasil evaluasi mencakup nilai loss, yang menunjukkan seberapa baik model cocok dengan data pelatihan, serta metrik akurasi dan skor F1 yang mengukur kinerja klasifikasi model. Akurasi mengukur proporsi prediksi yang benar, sedangkan skor F1 memberikan gambaran lebih komprehensif dengan mempertimbangkan keseimbangan antara precision dan recall.
# Evaluasi model
eval_results = trainer.evaluate()
# Menampilkan hasil evaluasi
print("Hasil Evaluasi:")
print(f"Loss: {eval_results['eval_loss']}")
print(f"Accuracy: {eval_results.get('eval_accuracy', 'Akurasi tidak tersedia')}")
print(f"F1 Score: {eval_results.get('eval_f1', 'F1 Score tidak tersedia')}")
Hasil evaluasi model menunjukkan bahwa model BERT yang telah dilatih memiliki kinerja yang baik pada data uji. Nilai loss adalah 0.6, yang mengukur seberapa baik model cocok dengan data. Semakin rendah nilainya, semakin baik model tersebut. Akurasi model adalah 0.8, yang berarti model berhasil memprediksi dengan benar 80% dari kasus. Selain itu, skor F1 adalah 0.711, yang menunjukkan bahwa model cukup baik dalam menghindari kesalahan, baik dalam hal memprediksi label yang benar maupun menghindari prediksi yang salah. Secara keseluruhan, model ini menunjukkan hasil yang solid dan seimbang dalam tugas klasifikasi sentimen.
Setelah evaluasi, model dan tokenizer disimpan menggunakan metode save_pretrained untuk memungkinkan penggunaan kembali atau penyebaran model tanpa harus melatihnya dari awal. Penyimpanan ini mencakup model terlatih dan tokenizer yang telah digunakan untuk memproses data, memastikan bahwa semua komponen yang diperlukan untuk inferensi di masa depan tersedia dan dapat diakses dengan mudah.
# Simpan model dan tokenizer
model.save_pretrained('./model')
tokenizer.save_pretrained('./tokenizer')Prediction
Untuk menggunakan model BERT yang telah dilatih dalam membuat prediksi, pertama-tama saya memuat tokenizer dan model yang telah disimpan sebelumnya. Tokenizer digunakan untuk mengubah teks menjadi format yang bisa diproses oleh model, sedangkan model yang telah dilatih digunakan untuk menghasilkan prediksi. Setelah memuat model dan tokenizer, saya mendefinisikan kalimat ulasan baru yang ingin diprediksi, yaitu “i love boruto”. Kalimat ini kemudian diproses oleh tokenizer untuk menghasilkan ID input yang diperlukan oleh model.
Model kemudian melakukan prediksi berdasarkan ID input tersebut. Output dari model menunjukkan probabilitas untuk setiap kelas, dan kelas dengan probabilitas tertinggi dipilih sebagai prediksi akhir. Dalam kasus ini, jika kelas yang diprediksi adalah 0, kalimat dianggap sebagai kelas negatif, sedangkan jika kelas yang diprediksi adalah 1, kalimat dianggap sebagai kelas positif. Proses ini memungkinkan kita untuk menentukan sentimen dari kalimat baru berdasarkan model yang telah dilatih sebelumnya.
# Load the tokenizer
tokenizer = BertTokenizer.from_pretrained('./tokenizer')
# Load the pre-trained model
model = BertForSequenceClassification.from_pretrained('./model')
# Define a new sentence to predict
new_sentence = "i love boruto"
# Preprocess the new sentence
input_ids = tokenizer.encode(new_sentence, return_tensors='pt')
# Predict the class
output = model(input_ids)[0]
predicted_class = output.argmax().item()
# Interpret the results
if predicted_class == 0:
print("Kalimat baru termasuk kelas negatif")
else:
print("Kalimat baru termasuk kelas positif")
Hasil prediksi menunjukkan bahwa kalimat “i love boruto” termasuk dalam kelas positif. Ini berarti model BERT mengidentifikasi kalimat tersebut sebagai memiliki sentimen positif, menunjukkan bahwa teks tersebut menyiratkan perasaan yang baik atau positif terhadap topik yang dibahas. Dengan kata lain, model telah menilai bahwa kalimat ini mengekspresikan dukungan atau kecintaan terhadap “Boruto”, yang sesuai dengan kategori positif yang telah ditetapkan dalam pelatihan model.
Terima kasih..
