initial commit

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+/venv
+/app/__pycache__

README.md

@@ -0,0 +1,12 @@
+---
+title: Useful Review Classification
+emoji: 🔥
+colorFrom: green
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.21.0
+app_file: app/main.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/main.py

@@ -0,0 +1,139 @@
+import torch
+import re
+import streamlit as st
+from transformers import BertTokenizer, BertModel
+from model import IndoBERTBiLSTM, IndoBERTModel
+
+# Config
+MAX_SEQ_LEN = 128
+bert_path = 'indolem/indobert-base-uncased'
+MODELS_PATH = ["kadabengaran/IndoBERT-Useful-App-Review",
+               "kadabengaran/IndoBERT-BiLSTM-Useful-App-Review"]
+
+            #    "kadabengaran/IndoBERT-BiLSTM-Useful-App-Review"]
+HIDDEN_DIM = 768
+OUTPUT_DIM = 2 # 2 if Binary
+N_LAYERS = 2
+BIDIRECTIONAL = True
+DROPOUT = 0.2
+
+# Get the Keys
+def get_key(val, my_dict):
+    for key, value in my_dict.items():
+        if val == value:
+            return key
+
+
+def get_device():
+    if torch.cuda.is_available():
+        return torch.device('cuda')
+    else:
+        return torch.device('cpu')
+
+
+def load_tokenizer(model_path):
+    tokenizer = BertTokenizer.from_pretrained(model_path)
+    return tokenizer
+
+
+def remove_special_characters(text):
+    # menghapus karakter khusus kecuali tanda baca seperti titik, koma, dan tanda tanya
+    # text = re.sub(r"[^a-zA-Z0-9.,!?]+", " ", text)
+    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
+    
+    # text = re.sub(r"'\s+|\s+'", " ", text)  # replace apostrophe with space if it's surrounded by whitespace
+    text = re.sub(r"\s+", " ", text)  # replace multiple whitespace characters with a single space
+    
+    text = re.sub(r'[0-9]', ' ', text) #remove number
+
+    text = text.lower()
+    return text
+
+
+def preprocess(text, tokenizer, max_seq=MAX_SEQ_LEN):
+    return tokenizer.encode_plus(text, add_special_tokens=True, max_length=max_seq,
+                                 pad_to_max_length=True,
+                                 return_attention_mask=True,
+                                 return_tensors='pt'
+                                 )
+    
+def load_model():
+    bert = BertModel.from_pretrained(bert_path)
+    
+	# Load the model
+    model1 = IndoBERTBiLSTM.from_pretrained(MODELS_PATH[0],
+                                     bert,
+                                     HIDDEN_DIM,
+                                     OUTPUT_DIM,
+                                     N_LAYERS, BIDIRECTIONAL,
+                                     DROPOUT)
+    model2 = IndoBERTModel.from_pretrained(MODELS_PATH[1],
+                                     bert,
+                                     OUTPUT_DIM)
+    return model1, model2
+
+
+def predict(text, model, tokenizer, device):
+    
+    # model = torch.load(model_path, map_location=device)
+    if device.type == 'cuda':
+        model.cuda()
+        
+    # We need Token IDs and Attention Mask for inference on the new sentence
+    test_ids = []
+    test_attention_mask = []
+
+    # Apply preprocessing to the new sentence
+    new_sentence = remove_special_characters(text)
+    encoding = preprocess(new_sentence, tokenizer)
+
+    # Extract IDs and Attention Mask
+    test_ids.append(encoding['input_ids'])
+    test_attention_mask.append(encoding['attention_mask'])
+    test_ids = torch.cat(test_ids, dim=0)
+    test_attention_mask = torch.cat(test_attention_mask, dim=0)
+
+    # Forward pass, calculate logit predictions
+    with torch.no_grad():
+        outputs = model(test_ids.to(device),
+                        test_attention_mask.to(device))
+    print("output ", outputs)
+    predictions = torch.argmax(outputs, dim=-1)
+    print("output ", predictions)
+    return predictions.item()
+
+def main():
+    """App Review Classifier"""
+    # st.title("Klasifikasi Ulasan APlikasi")
+    # st.subheader("ML App with Streamlit")
+    html_temp = """
+	<div style="background-color:blue;padding:10px">
+	<h1 style="color:white;text-align:center;">Klasifikasi Ulasan Aplikasi yang Berguna</h1>
+	</div>
+
+	"""
+    st.markdown(html_temp, unsafe_allow_html=True)
+    # st.info("Prediction with ML")
+
+    input_text = st.text_area("Enter Text Here", placeholder="Type Here")
+    all_ml_models = ["IndoBERT", "IndoBERT-BiLSTM"]
+    model_choice = st.selectbox("Select Model", all_ml_models)
+
+    tokenizer = load_tokenizer(bert_path)
+    device = get_device()
+    model1, model2 = load_model()
+    
+    prediction = 0
+    prediction_labels = {'Not Useful': 0, 'Useful': 1}
+    if st.button("Classify"):
+        st.text("Original Text:\n{}".format(input_text))
+        if model_choice == 'IndoBERT':
+            prediction = predict(input_text, model1, tokenizer, device)
+        elif model_choice == 'IndoBERT-BiLSTM':
+            prediction = predict(input_text, model2, tokenizer, device)
+        final_result = get_key(prediction, prediction_labels)
+        st.success("Review Categorized as:: {}".format(final_result))
+    # st.sidebar.subheader("About")
+
+if __name__ == '__main__':
+    main()

app/model.py

@@ -0,0 +1,88 @@
+import torch.nn as nn
+from transformers import PreTrainedModel, BertConfig
+
+USE_CUDA = False
+
+class IndoBERTBiLSTM(PreTrainedModel):
+    config_class = BertConfig
+    def __init__(self, bert_config, bert_pretrained_path, hidden_dim, num_classes, n_layers, bidirectional, dropout):
+        super().__init__(bert_config)
+        self.output_dim = num_classes
+        self.n_layers = n_layers
+        self.hidden_dim = hidden_dim
+        self.bidirectional = bidirectional
+
+        self.bert = bert_pretrained_path
+        self.lstm = nn.LSTM(input_size=self.bert.config.hidden_size,
+                            hidden_size=hidden_dim,
+                            num_layers=n_layers,
+                            bidirectional=bidirectional,
+                            batch_first=True)
+        self.dropout = nn.Dropout(dropout)
+        self.global_pooling = nn.AdaptiveAvgPool1d(1)
+        self.hidden_layer = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, hidden_dim * 2 if bidirectional else hidden_dim)
+        self.output_layer = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, num_classes)
+        self.relu = nn.ReLU()
+
+    def forward(self, input_ids, attention_mask):
+
+        hidden = self.init_hidden(input_ids.shape[0])
+        # print("hidden : ", type(hidden))
+        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        sequence_output = output.last_hidden_state
+
+        # apply dropout
+        sequence_output = self.dropout(sequence_output)
+        # print('output size of the bert:', last_hidden_state.size())
+    
+        lstm_output, (hidden_last, cn_last) = self.lstm(sequence_output, hidden)
+        # print('output size of the LSTM:', lstm_output.size())
+        lstm_output = self.dropout(lstm_output)
+
+        # global pooling
+        lstm_output = lstm_output.permute(0, 2, 1)
+        pooled_output = self.global_pooling(lstm_output).squeeze()
+
+        # pass through hidden layer
+        hidden_layer_output = self.hidden_layer(pooled_output)
+        hidden_layer_output = self.relu(hidden_layer_output)
+
+        # output layer
+        logits = self.output_layer(hidden_layer_output)
+        # logits = nn.Softmax(dim=1)(logits)
+
+        return logits
+
+    def init_hidden(self, batch_size):
+        weight = next(self.parameters()).data
+        
+        number = 1
+        if self.bidirectional:
+            number = 2
+        
+        if (USE_CUDA):
+            hidden = (weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float().cuda(),
+                      weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float().cuda()
+                     )
+        else:
+            hidden = (weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float(),
+                      weight.new(self.n_layers*number, batch_size, self.hidden_dim).zero_().float()
+                     )
+        
+        return hidden
+    
+
+class IndoBERTModel(PreTrainedModel):
+    config_class = BertConfig
+    def __init__(self, bert_config, bert_pretrained, num_classes):
+        super().__init__(bert_config)
+        self.bert = bert_pretrained
+        self.dropout = nn.Dropout(0.1)
+        self.fc = nn.Linear(self.bert.config.hidden_size, num_classes)
+
+    def forward(self, input_ids, attention_mask):
+        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        pooled_output = outputs.pooler_output
+        pooled_output = self.dropout(pooled_output)
+        logits = self.fc(pooled_output)
+        return logits

howto.txt

@@ -0,0 +1,7 @@
+python -m venv --system-site-packages .\venv
+
+.\venv\Scripts\activate
+
+pip install -r requirements.txt
+
+streamlit run app/main.py

requirements.txt

@@ -0,0 +1,6 @@
+streamlit
+torch
+torchvision
+transformers
+tokenizers
+pickleshare