Farih.co.id
Home Programming Cara Membuat Model Analisis Sentimen dari Awal

Cara Membuat Model Analisis Sentimen dari Awal

Analisis sentimen adalah teknik pemrosesan bahasa alami (NLP) yang mengidentifikasi sikap di balik sebuah teks. Ini juga dikenal sebagai penambangan opini. Tujuan analisis sentimen adalah untuk mengidentifikasi apakah teks tertentu memiliki sentimen positif, negatif, atau netral. Ini banyak digunakan oleh bisnis untuk secara otomatis mengklasifikasikan sentimen dalam ulasan pelanggan. Menganalisis ulasan dalam jumlah besar membantu mendapatkan wawasan berharga tentang preferensi pelanggan.


Menyiapkan Lingkungan Anda

Anda harus terbiasa dengan dasar-dasar Python untuk menindaklanjutinya. Navigasi ke Google Colab atau buka Jupyter Notebook. Kemudian buat buku catatan baru. Jalankan perintah berikut untuk menginstal pustaka yang diperlukan di lingkungan Anda.

 ! pip install tensorflow scikit-learn pandas numpy pickle5

Anda akan menggunakan perpustakaan NumPy dan panda untuk memanipulasi kumpulan data. TensorFlow untuk membuat dan melatih model machine learning. Scikit-learn untuk memisahkan dataset menjadi set pelatihan dan pengujian. Terakhir, Anda akan menggunakan pickle5 untuk membuat serial dan menyimpan objek tokenizer.

Mengimpor Perpustakaan yang Diperlukan

Impor pustaka yang diperlukan yang akan Anda gunakan untuk melakukan praproses data dan membuat model.

 import numpy as np
import pandas as pd
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Conv1D, GlobalMaxPooling1D, Dense, Dropout
import pickle5 as pickle

Anda akan menggunakan kelas yang Anda impor dari modul nanti dalam kode.

Memuat Kumpulan Data

Di sini, Anda akan menggunakan kumpulan data Ulasan Hotel Trip Advisor dari Kaggle untuk membangun model analisis sentimen.

 df = pd.read_csv('/content/tripadvisor_hotel_reviews.csv')
print(df.head())

Muat dataset dan cetak lima baris pertamanya. Mencetak lima baris pertama akan membantu Anda memeriksa nama kolom kumpulan data Anda. Ini akan sangat penting saat melakukan pra-pemrosesan dataset.

Keluaran yang menampilkan lima baris pertama kumpulan data

Kumpulan data Ulasan Hotel Trip Advisor memiliki kolom indeks, kolom Ulasan, dan kolom Peringkat.

Pra-pemrosesan Data

Pilih Tinjauan Dan Peringkat kolom dari kumpulan data. Buat kolom baru berdasarkan kolom Peringkat dan beri nama sentimen. Jika peringkatnya lebih besar dari 3, beri label sentimen sebagai positif. Jika peringkatnya kurang dari 3, beri label sebagai negatif. Jika peringkatnya tepat 3, beri label sebagai netral.

Pilih hanya kolom Ulasan dan sentimen dari kumpulan data. Kocok baris secara acak dan setel ulang indeks bingkai data. Pengacakan dan pengaturan ulang memastikan data didistribusikan secara acak, yang diperlukan untuk pelatihan dan pengujian model yang tepat.

 df = df[['Review', 'Rating']]
df['sentiment'] = df['Rating'].apply(lambda x: 'positive' if x > 3
                                    else 'negative' if x < 3
                                    else 'neutral')
df = df[['Review', 'sentiment']]
df = df.sample(frac=1).reset_index(drop=True)

Mengkonversi Tinjauan teks menjadi urutan bilangan bulat menggunakan tokenizer. Ini membuat kamus kata-kata unik yang ada dalam teks Ulasan dan memetakan setiap kata ke nilai bilangan bulat unik. Menggunakan pad_sequences fungsi dari Keras untuk memastikan bahwa semua urutan ulasan memiliki panjang yang sama.

 tokenizer = Tokenizer(num_words=5000, oov_token='<OOV>')
tokenizer.fit_on_texts(df['Review'])
word_index = tokenizer.word_index
sequences = tokenizer.texts_to_sequences(df['Review'])
padded_sequences = pad_sequences(sequences, maxlen=100, truncating='post')

Ubah label sentimen menjadi pengkodean One-hot.

 sentiment_labels = pd.get_dummies(df['sentiment']).values

Pengkodean satu-panas mewakili data kategorikal dalam format yang lebih mudah digunakan oleh model Anda.

Memisahkan Set Data Menjadi Set Pelatihan dan Pengujian

Gunakan scikit-learn untuk membagi dataset secara acak menjadi set pelatihan dan pengujian. Anda akan menggunakan set pelatihan untuk melatih model untuk mengklasifikasikan sentimen ulasan. Dan Anda akan menggunakan set pengujian untuk mengakses seberapa bagus model dalam mengklasifikasikan ulasan baru yang tidak terlihat.

 x_train, x_test, y_train, y_test = train_test_split(padded_sequences, sentiment_labels, test_size=0.2)

Ukuran pemisahan dataset adalah 0,2. Artinya, 80% data akan melatih model. Dan 20% sisanya akan menguji performa model.

Membuat Jaringan Neural

Buat jaringan saraf dengan enam lapisan.

 model = Sequential()
model.add(Embedding(5000, 100, input_length=100))
model.add(Conv1D(64, 5, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()

Lapisan pertama dari jaringan saraf adalah lapisan Embedding. Lapisan ini mempelajari representasi padat dari kata-kata dalam kosakata. Lapisan kedua adalah lapisan Conv1D dengan 64 filter dan ukuran kernel 5. Lapisan ini melakukan operasi konvolusi pada urutan masukan, menggunakan jendela geser kecil berukuran 5.

Lapisan ketiga mengurangi urutan peta fitur menjadi satu vektor. Dibutuhkan nilai maksimum untuk setiap peta fitur. Lapisan keempat melakukan transformasi linier pada vektor input. Lapisan kelima secara acak menetapkan sebagian kecil dari unit input menjadi 0 selama pelatihan. Ini membantu mencegah overfitting. Lapisan terakhir mengubah output menjadi distribusi probabilitas atas tiga kemungkinan kelas: positif, netral, dan negatif.

Melatih Neural Network

Sesuaikan set pelatihan dan pengujian dengan model. Latih model selama sepuluh zaman. Anda dapat mengubah jumlah zaman sesuai keinginan Anda.

 model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

Setelah setiap zaman, performa model pada set pengujian dievaluasi.

Mengevaluasi Kinerja Model Terlatih

Menggunakan model.prediksi() metode untuk memprediksi label sentimen untuk set tes. Menghitung skor akurasi menggunakan akurasi_skor() fungsi dari scikit-belajar.

 y_pred = np.argmax(model.predict(x_test), axis=-1)
print("Accuracy:", accuracy_score(np.argmax(y_test, axis=-1), y_pred))

Akurasi model ini sekitar 84%.

Menyimpan Model

Simpan model menggunakan model.save() metode. Gunakan acar untuk membuat cerita bersambung dan menyimpan objek tokenizer.

 model.save('sentiment_analysis_model.h5')
with open('tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)

Objek tokenizer akan memberi token teks input Anda sendiri dan menyiapkannya untuk dimasukkan ke model terlatih.

Menggunakan Model untuk Mengklasifikasikan Sentimen Teks Anda Sendiri

Setelah membuat dan menyimpan model, Anda dapat menggunakannya untuk mengklasifikasikan sentimen teks Anda sendiri. Pertama, muat model dan tokenizer yang disimpan.

 
import keras

model = keras.models.load_model('sentiment_analysis_model.h5')
with open('tokenizer.pickle', 'rb') as handle:
    tokenizer = pickle.load(handle)

Tentukan fungsi untuk memprediksi sentimen teks masukan.

 def predict_sentiment(text):
    
    text_sequence = tokenizer.texts_to_sequences([text])
    text_sequence = pad_sequences(text_sequence, maxlen=100)

    
    predicted_rating = model.predict(text_sequence)[0]
    if np.argmax(predicted_rating) == 0:
        return 'Negative'
    elif np.argmax(predicted_rating) == 1:
        return 'Neutral'
    else:
        return 'Positive'

Terakhir, prediksi teks Anda sendiri.

 text_input = "I absolutely loved my stay at that hotel. The staff was amazing and the room was fantastic!"
predicted_sentiment = predict_sentiment(text_input)
print(predicted_sentiment)

Sentimen yang diprediksi dari ulasan di atas adalah sebagai berikut:

Keluaran model analisis sentimen di Google Colab

Model mampu mengklasifikasikan sentimen dari ketiga review dengan benar.

Memprediksi Sentimen Menggunakan Model Pra-Terlatih

Terkadang dalam pembelajaran mesin, Anda mungkin memiliki tantangan untuk menemukan kumpulan data yang tepat. Anda mungkin juga kekurangan sumber daya untuk membuat kumpulan data Anda sendiri. Di sinilah model pra-terlatih masuk. Anda harus tahu cara menggunakan API mereka dan membiarkan mereka menangani sisanya.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad