[General] Initial commit

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+
+venv/
+__pycache__/

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor="#262730"
+backgroundColor="#ffffff"
+secondaryBackgroundColor="#f6f6f8"
+textColor="#090909"
+font="sans serif"

app.py

@@ -0,0 +1,62 @@
+import streamlit as st
+
+from modules.prediction import prepare, predict
+
+STATUS_STOPPED = 120001
+STATUS_SUBMIT = 120002
+STATUS_ERROR = 120003
+
+has_prepared = False
+
+st.session_state['running_status'] = STATUS_STOPPED
+
+if not has_prepared:
+    print('>>> [PREPARE] Preparing...')
+    prepare()
+    has_prepared = True
+
+st.title('Entity Referring Classifier')
+st.caption('It knows exactly when you are calling it. - Version 2.0.1208.01')
+
+st.markdown('---')
+
+livedemo_col1, livedemo_col2, livedemo_col3 = st.columns([12,1,6])
+
+with livedemo_col1:
+    st.subheader('Live Demo')
+
+    with st.form("my_form"):
+        entity = st.text_input('Entity Name', 'Jimmy')
+        sentence = st.text_input('Text Input', 'Hey Jimmy.',
+                help='The classifier is going to analyze this sentence.')
+        if st.form_submit_button('Submit it'):
+            st.session_state['running_status'] = STATUS_SUBMIT
+
+    if st.session_state['running_status'] == STATUS_STOPPED:
+        st.info('Type something and submit to start!')
+    elif st.session_state['running_status'] == STATUS_SUBMIT:
+        if predict(sentence, entity) == 'CALLING':
+            st.success('It is a **calling**!')
+        else:
+            st.success('It is a **mentioning**!')
+
+with livedemo_col2:
+    st.empty()
+
+with livedemo_col3:
+    st.markdown("""
+    #### Get Started
+    """)
+    st.markdown("""
+    Hi! I'm the Entity Referring Classifier.
+    I can help you find out when you are calling it.
+    """)
+    st.markdown("""
+    #### Terms
+    """)
+    st.markdown("""
+    ##### `Calling`
+    """)
+    st.markdown("""
+    ##### `Mentioning`
+    """)

modules/prediction/ERCBCM.py

@@ -0,0 +1,13 @@
+from torch import nn
+from transformers import BertForSequenceClassification
+
+class ERCBCM(nn.Module):
+  
+    def __init__(self):
+        super(ERCBCM, self).__init__()
+
+        self.encoder = BertForSequenceClassification.from_pretrained('bert-base-uncased')
+
+    def forward(self, text, label):
+        loss, text_fea = self.encoder(text, labels=label)[:2]
+        return loss, text_fea

modules/prediction/__init__.py

@@ -0,0 +1,36 @@
+import os, sys
+
+myPath = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, myPath + '/../../')
+
+# ==========
+
+import torch
+
+from modules.prediction.model_loader import load_checkpoint
+from modules.prediction.ERCBCM import ERCBCM
+from modules.tokenizer import tokenizer, normalize_v2, PAD_TOKEN_ID
+
+erc_root_folder = './model'
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# ==========
+
+model_for_evaluate = ERCBCM().to(device)
+
+def prepare():
+    load_checkpoint(erc_root_folder + '/model.pt', model_for_evaluate, device)
+
+def predict(sentence, name):
+    label = torch.tensor([0])
+    label = label.type(torch.LongTensor)
+    label = label.to(device)
+    text = tokenizer.encode(normalize_v2(sentence, name))
+    text += [PAD_TOKEN_ID] * (128 - len(text))
+    text = torch.tensor([text])
+    text = text.type(torch.LongTensor)
+    text = text.to(device)
+    _, output = model_for_evaluate(text, label)
+    pred = torch.argmax(output, 1).tolist()[0]
+    return 'CALLING' if pred == 1 else 'MENTIONING'

modules/prediction/model_loader.py

@@ -0,0 +1,35 @@
+import torch
+
+# Save and Load Functions
+
+def save_checkpoint(save_path, model, valid_loss):
+    if save_path == None:
+        return
+    state_dict = {'model_state_dict': model.state_dict(),
+                  'valid_loss': valid_loss}
+    torch.save(state_dict, save_path)
+    print('[SAVE] Model has been saved successfully to \'{}\''.format(save_path))
+
+def load_checkpoint(load_path, model, device):
+    if load_path == None:
+        return
+    state_dict = torch.load(load_path, map_location=device)
+    print('[LOAD] Model has been loaded successfully from \'{}\''.format(load_path))
+    model.load_state_dict(state_dict['model_state_dict'])
+    return state_dict['valid_loss']
+
+def save_metrics(save_path, train_loss_list, valid_loss_list, global_steps_list):
+    if save_path == None:
+        return
+    state_dict = {'train_loss_list': train_loss_list,
+                  'valid_loss_list': valid_loss_list,
+                  'global_steps_list': global_steps_list}
+    torch.save(state_dict, save_path)
+    print('[SAVE] Model with matrics has been saved successfully to \'{}\''.format(save_path))
+
+def load_metrics(load_path, device):
+    if load_path == None:
+        return
+    state_dict = torch.load(load_path, map_location=device)
+    print('[LOAD] Model with matrics has been loaded successfully from \'{}\''.format(load_path))
+    return state_dict['train_loss_list'], state_dict['valid_loss_list'], state_dict['global_steps_list']

modules/tokenizer/__init__.py

@@ -0,0 +1,15 @@
+from transformers import BertTokenizer
+
+tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
+
+# Parameters preparation.
+MAX_SENT_LENGTH = 128
+PAD_TOKEN_ID = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
+
+def normalize_v2(text, entity):
+    text = text.lower()
+    entity = entity.lower()
+    if entity not in text:
+        return text
+    text = text.replace(entity, tokenizer.mask_token) # TODO: not sure if this will be decoded by BERT.
+    return text

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+torch
+torchtext
+ipywidgets
+transformers