First Commit

app.py

@@ -0,0 +1,34 @@
+# import libraries
+import streamlit as st
+import predict
+import logging
+
+# Logging configuration
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Load necessary components
+df = predict.load_dataset()
+model, tokenizer = predict.load_model_and_tokenizer()
+
+if df is not None and model is not None and tokenizer is not None:
+    # Preprocess dataset and prepare stopwords and stemmer
+    manual_stopwords = ["di", "ke", "dari", "yang", "dan", "atau", "dengan", "untuk", "ini", "itu", "aja", "saja", "lah", "bri", "brimo", "aplikasi", "rekening", "coba", "yg", "ke", "untuk", "nya", "saya", "dia", "dan", "sangat", "video", "login", "apk", "jadi", "akun", "malah", "uang", "banget", "dalam", "atm", "padahal"]
+    stop_words = set(predict.stopwords.words('indonesian'))
+    stop_words.update(manual_stopwords)
+    factory = predict.StemmerFactory()
+    stemmer = factory.create_stemmer()
+    df['label'] = df['score'].apply(predict.map_labels)
+
+    navigation = st.sidebar.selectbox('Choose Page:', ('predictor', 'eda'))
+
+    if navigation == 'predictor':
+        predict.run(model, tokenizer, stop_words, stemmer)
+    # elif navigation == 'eda':
+    #     eda.run()
+else:
+    if df is None:
+        logging.error("Failed to load dataset.")
+        st.error("Failed to load the dataset. Please check the dataset file.")
+    if model is None or tokenizer is None:
+        logging.error("Failed to load model or tokenizer.")
+        st.error("Failed to load the model or tokenizer. Please check the model file.")

best_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:207d19ec305831f9f0e1bf5ec0d7f76b79d912de521c39a405bf4ff42890f26e
+size 498080376

predict.py

@@ -0,0 +1,206 @@
+# Import libraries
+import logging
+import re
+import pandas as pd
+import numpy as np
+import tensorflow as tf
+import nltk
+from Sastrawi.Stemmer.StemmerFactory import StemmerFactory
+from transformers import AutoTokenizer, TFBertModel
+from tensorflow.keras import backend as K
+from tensorflow.keras.models import load_model
+from tensorflow.keras.layers import Layer
+from tensorflow_addons.optimizers import AdamW
+import streamlit as st
+from nltk.corpus import stopwords
+from concurrent.futures import ThreadPoolExecutor
+import kagglehub
+import os
+
+# Text Processing
+nltk.download('punkt')
+nltk.download('stopwords')
+
+# Logging configuration
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Load dataset
+def load_dataset():
+    try:
+        path = kagglehub.dataset_download("dannytheodore/brimo-app-review")
+        dataset_path = f"{path}/brimo_googleplaystore_review.csv"
+        return pd.read_csv(dataset_path, index_col=0)
+    except Exception as e:
+        logging.error(f"Error loading dataset: {e}")
+        st.error("Failed to load the dataset.")
+        return None
+
+# Map the labels to positive, neutral, negative
+def map_labels(score):
+    if score >= 4:
+        return 2  # Positive
+    elif score == 3:
+        return 1  # Neutral
+    else:
+        return 0  # Negative
+
+# Preprocess text
+def preprocess_text(text, stop_words, stemmer):
+    try:
+        text = text.lower()
+        text = re.sub(r"@[A-Za-z0-9_]+", " ", text)  # Remove mentions
+        text = re.sub(r"#[A-Za-z0-9_]+", " ", text)  # Remove hashtags
+        text = re.sub(r"http\S+", " ", text)  # Remove URLs
+        text = re.sub(r"www.\S+", " ", text)  # Remove www URLs
+        text = re.sub(r"[^A-Za-z\s']", " ", text)  # Remove non-letter characters
+        tokens = text.split()
+        tokens = [word for word in tokens if word not in stop_words]  # Remove stopwords
+        tokens = [stemmer.stem(word) for word in tokens]  # Apply stemming
+        return ' '.join(tokens)
+    except Exception as e:
+        logging.error(f"Error processing text: {text}\n{e}")
+        return text
+
+# Preprocess and tokenize reviews asynchronously
+def preprocess_and_tokenize_reviews(reviews, tokenizer, stop_words, stemmer, max_length=128):
+    with ThreadPoolExecutor() as executor:
+        cleaned_reviews = list(executor.map(lambda x: preprocess_text(x, stop_words, stemmer), reviews))
+    return tokenizer(cleaned_reviews, padding='max_length', truncation=True, max_length=max_length, return_tensors='tf')
+
+# Custom Keras Layer
+class BertLayer(Layer):
+    def __init__(self, base_model, **kwargs):
+        super(BertLayer, self).__init__(**kwargs)
+        self.base_model = base_model
+
+    def call(self, inputs):
+        input_ids, attention_mask = inputs
+        outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)
+        return outputs.last_hidden_state
+
+    def get_config(self):
+        config = super(BertLayer, self).get_config()
+        config.update({"base_model": self.base_model})
+        return config
+
+# Add Pooler Layer (from the first [CLS] token)
+class PoolerLayer(Layer):
+    def __init__(self, **kwargs):
+        super(PoolerLayer, self).__init__(**kwargs)
+
+    def call(self, inputs):
+        cls_token = inputs[:, 0, :]  # First token's output (the [CLS] token)
+        pooled_output = tf.keras.activations.tanh(cls_token)  # Apply tanh activation
+        return pooled_output
+
+# Custom F1 Score Metric
+class F1Score(tf.keras.metrics.Metric):
+    def __init__(self, name="f1_score", **kwargs):
+        super(F1Score, self).__init__(name=name, **kwargs)
+        self.true_positives = self.add_weight(name="tp", initializer="zeros")
+        self.false_positives = self.add_weight(name="fp", initializer="zeros")
+        self.false_negatives = self.add_weight(name="fn", initializer="zeros")
+
+    def update_state(self, y_true, y_pred, sample_weight=None):
+        y_pred = tf.argmax(y_pred, axis=-1)
+        y_true = tf.argmax(y_true, axis=-1)
+        tp = tf.reduce_sum(tf.cast((y_true == y_pred) & (y_true != 0), tf.float32))
+        fp = tf.reduce_sum(tf.cast((y_true != y_pred) & (y_pred != 0), tf.float32))
+        fn = tf.reduce_sum(tf.cast((y_true != y_pred) & (y_true != 0), tf.float32))
+        self.true_positives.assign_add(tp)
+        self.false_positives.assign_add(fp)
+        self.false_negatives.assign_add(fn)
+
+    def result(self):
+        precision = self.true_positives / (self.true_positives + self.false_positives + K.epsilon())
+        recall = self.true_positives / (self.true_positives + self.false_negatives + K.epsilon())
+        f1 = 2 * (precision * recall) / (precision + recall + K.epsilon())
+        return f1
+
+    def reset_state(self):
+        self.true_positives.assign(0)
+        self.false_positives.assign(0)
+        self.false_negatives.assign(0)
+
+# Load model and tokenizer
+def load_model_and_tokenizer():
+    try:
+        model_path = 'best_model.h5'
+        if os.path.exists(model_path):
+            model = load_model(model_path, custom_objects={'TFBertModel': TFBertModel, 'BertLayer': BertLayer, 'PoolerLayer': PoolerLayer, 'F1Score': F1Score})
+        else:
+            st.error("Model file not found. Please check the file path.")
+            return None, None
+    except Exception as e:
+        logging.error(f"Error loading model: {e}")
+        st.error("Failed to load the model. Please check the model file and try again.")
+        return None, None
+
+    # Recreate the AdamW optimizer
+    optimizer = AdamW(learning_rate=2e-5, weight_decay=1e-5)
+
+    # Recompile the model with the AdamW optimizer
+    model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=[F1Score()])
+
+    # Load tokenizer from the tokenizer folder
+    try:
+        tokenizer = AutoTokenizer.from_pretrained('indobenchmark/indobert-base-p1')
+    except Exception as e:
+        logging.error(f"Error loading tokenizer: {e}")
+        st.error("Failed to load the tokenizer. Please check the tokenizer files.")
+        return None, None
+
+    return model, tokenizer
+
+
+# Sentiment mapping
+sentiment_map = {0: 'Negative', 1: 'Neutral', 2: 'Positive'}
+
+# Run Streamlit app
+def run(model, tokenizer, stop_words, stemmer):
+    # Set title and description
+    st.title('Sentiment Analysis using IndoBERT')
+    st.subheader('This application analyzes the sentiment of user-provided reviews.')
+
+    # Input form
+    with st.form(key='review_form'):
+        review_input = st.text_area("Enter Review:", height=150)
+        submit_button = st.form_submit_button("Analyze Sentiment")
+
+    if submit_button:
+        if review_input:
+            # Preprocess and tokenize the review
+            tokenized_review = preprocess_and_tokenize_reviews([review_input], tokenizer, stop_words, stemmer)
+
+            # Make prediction
+            if model:
+                predictions = model.predict({'input_ids': tokenized_review['input_ids'], 'attention_mask': tokenized_review['attention_mask']})
+                predicted_label = np.argmax(predictions, axis=-1)
+                sentiment = sentiment_map[predicted_label[0]]
+                st.write(f"### Predicted Sentiment: {sentiment}")
+            else:
+                st.error("Model is not loaded. Please check the model file and try again.")
+        else:
+            st.error("Please enter a review to analyze.")
+
+if __name__ == "__main__":
+    # Load necessary components
+    df = load_dataset()
+    model, tokenizer = load_model_and_tokenizer()
+
+    if df is not None and model is not None and tokenizer is not None:
+        # Preprocess dataset and prepare stopwords and stemmer
+        manual_stopwords = ["di", "ke", "dari", "yang", "dan", "atau", "dengan", "untuk", "ini", "itu", "aja", "saja", "lah", "bri", "brimo", "aplikasi", "rekening", "coba", "yg", "ke", "untuk", "nya", "saya", "dia", "dan", "sangat", "video", "login", "apk", "jadi", "akun", "malah", "uang", "banget", "dalam", "atm", "padahal"]
+        stop_words = set(stopwords.words('indonesian'))
+        stop_words.update(manual_stopwords)
+        factory = StemmerFactory()
+        stemmer = factory.create_stemmer()
+        df['label'] = df['score'].apply(map_labels)
+        run(model, tokenizer, stop_words, stemmer)
+    else:
+        if df is None:
+            logging.error("Failed to load dataset.")
+            st.error("Failed to load the dataset. Please check the dataset file.")
+        if model is None or tokenizer is None:
+            logging.error("Failed to load model or tokenizer.")
+            st.error("Failed to load the model or tokenizer. Please check the model file.")

requirements.txt

@@ -0,0 +1,10 @@
+tensorflow==2.11.0
+tensorflow-addons
+Sastrawi
+datasets
+transformers
+kagglehub
+nltk
+streamlit
+pandas
+numpy

tokenizer/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer/tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}