|
import streamlit as st |
|
import torch |
|
import torch.nn as nn |
|
import pandas as pd |
|
import numpy as np |
|
import pickle |
|
from nltk.tokenize import RegexpTokenizer |
|
from nltk.corpus import stopwords |
|
from sklearn.feature_extraction.text import TfidfVectorizer |
|
from sklearn.linear_model import LogisticRegression |
|
import re |
|
import string |
|
from nltk.stem import WordNetLemmatizer |
|
import time |
|
import transformers |
|
import json |
|
import nltk |
|
nltk.download('stopwords') |
|
nltk.download('wordnet') |
|
nltk.download('punkt') |
|
nltk.download('averaged_perceptron_tagger') |
|
|
|
from biLSTM1 import biLSTM |
|
from lstm_preprocessing import ( |
|
data_preprocessing, |
|
get_words_by_freq, |
|
padding, |
|
preprocess_single_string |
|
) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
with open('logistic_regression_model.pkl', 'rb') as file: |
|
loaded_model_1 = pickle.load(file) |
|
|
|
with open('tfidf_vectorizer.pkl', 'rb') as file: |
|
vectorizer_1 = pickle.load(file) |
|
|
|
|
|
stop_words = stopwords.words('english') |
|
|
|
tokenizer = RegexpTokenizer(r'\w+') |
|
|
|
def data_preprocessing(text: str) -> str: |
|
"""preprocessing string: lowercase, removing html-tags, punctuation and stopwords |
|
|
|
Args: |
|
text (str): input string for preprocessing |
|
|
|
Returns: |
|
str: preprocessed string |
|
""" |
|
|
|
text = text.lower() |
|
text = re.sub('<.*?>', '', text) |
|
text = ''.join([c for c in text if c not in string.punctuation]) |
|
lemmatizer = WordNetLemmatizer() |
|
tokens = tokenizer.tokenize(text) |
|
tokens = [lemmatizer.lemmatize(word) for word in tokens if not word.isdigit() and word not in stop_words] |
|
return ' '.join(tokens) |
|
|
|
|
|
|
|
|
|
|
|
def load_model_l(): |
|
model_finetuned = transformers.AutoModel.from_pretrained( |
|
"nghuyong/ernie-2.0-base-en", |
|
output_attentions = False, |
|
output_hidden_states = False |
|
) |
|
model_finetuned.load_state_dict(torch.load('ErnieModel_imdb.pt', map_location=torch.device('cpu'))) |
|
tokenizer = transformers.AutoTokenizer.from_pretrained("nghuyong/ernie-2.0-base-en") |
|
return model_finetuned, tokenizer |
|
|
|
def preprocess_text(text_input, max_len, tokenizer): |
|
input_tokens = tokenizer( |
|
text_input, |
|
return_tensors='pt', |
|
padding=True, |
|
max_length=max_len, |
|
truncation = True |
|
) |
|
return input_tokens |
|
|
|
def predict_sentiment(model, input_tokens): |
|
id2label = {0: "negative", 1: "positive"} |
|
output = model(**input_tokens).pooler_output.detach().numpy() |
|
with open('LogReg_imdb_Ernie.pkl', 'rb') as file: |
|
cls = pickle.load(file) |
|
result = id2label[int(cls.predict(output))] |
|
return result |
|
|
|
|
|
|
|
with open('vocab_to_int.json', 'r') as fp: |
|
vocab_to_int = json.load(fp) |
|
|
|
|
|
VOCAB_SIZE = len(vocab_to_int)+1 |
|
EMBEDDING_DIM = 32 |
|
HIDDEN_DIM = 64 |
|
N_LAYERS = 3 |
|
SEQ_LEN = 128 |
|
|
|
def load_model_g(): |
|
model = biLSTM( |
|
vocab_size=VOCAB_SIZE, |
|
embedding_dim=EMBEDDING_DIM, |
|
hidden_dim=HIDDEN_DIM, |
|
n_layers=N_LAYERS |
|
) |
|
model.load_state_dict(torch.load('biLSTM_model_do_05_lr001_best.pt', map_location=torch.device('cpu'))) |
|
return model |
|
|
|
device = 'cuda' if torch.cuda.is_available() else 'cpu' |
|
|
|
def predict_sentence(text: str, model: nn.Module) -> str: |
|
id2label = {0: "negative", 1: "positive"} |
|
output = model.to(device)(preprocess_single_string(text, SEQ_LEN, vocab_to_int).unsqueeze(0).to(device)) |
|
pred = int(output.round().item()) |
|
result = id2label[pred] |
|
return result |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def main(): |
|
st.title('Sentiment Analysis App') |
|
st.header('Classic ML, ErnieModel, bidirectional LSTM') |
|
user_input = st.text_area('Please enter your review:') |
|
st.write(user_input) |
|
submit = st.button("Predict!") |
|
col1, col2,col3 = st.columns(3) |
|
if user_input is not None and submit: |
|
with col1: |
|
|
|
preprocessed_input_1 = data_preprocessing(user_input) |
|
|
|
input_vector = vectorizer_1.transform([preprocessed_input_1]) |
|
start_time = time.time() |
|
proba_1 = loaded_model_1.predict_proba(input_vector)[:, 1] |
|
|
|
|
|
prediction_1 = round(proba_1[0]) |
|
end_time = time.time() |
|
st.header('Classic ML (LogReg on TF-IDF)') |
|
|
|
if prediction_1 == 0: |
|
st.write('The sentiment of your review is negative.') |
|
st.write('Predicted probability:', (1 - round(proba_1[0], 2))*100, '%') |
|
else: |
|
st.write('The sentiment of your review is positive.') |
|
st.write('Processing time:', round(end_time - start_time, 4), 'seconds') |
|
|
|
if user_input is not None and submit: |
|
with col2: |
|
model2, tokenizer = load_model_l() |
|
start_time = time.time() |
|
input_tokens = preprocess_text(user_input, 500, tokenizer) |
|
output = predict_sentiment(model2, input_tokens) |
|
end_time = time.time() |
|
st.header('ErnieModel') |
|
st.write('The sentiment of your review is', output) |
|
st.write('Processing time:', round(end_time - start_time, 4), 'seconds') |
|
|
|
if user_input is not None and submit: |
|
with col3: |
|
model3 = load_model_g() |
|
start_time = time.time() |
|
output = predict_sentence(user_input,model3) |
|
end_time = time.time() |
|
st.header('bidirectional LSTM') |
|
st.write('The sentiment of your review is', output) |
|
st.write('Processing time:', round(end_time - start_time, 4), 'seconds') |
|
|
|
|
|
|
|
|
|
if __name__ == '__main__': |
|
main() |
|
|
|
|
