Upload app.py

app.py

@@ -0,0 +1,154 @@
+import pandas as pd
+import pickle as pkl
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from sklearn.dummy import DummyClassifier
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.linear_model import Perceptron
+from numpy import reshape
+import numpy as np
+from sklearn.metrics import accuracy_score
+from sklearn.metrics import classification_report
+from sklearn.naive_bayes import GaussianNB
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.linear_model import Perceptron
+from sklearn.dummy import DummyClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.neural_network import MLPClassifier
+from sklearn import svm
+import gradio as gr
+
+class NLP:
+    def __init__(self) -> None:
+        self.__path = "models/"
+        self.__exec = {"Perceptron": [self.perceptron_pol_eval, self.perceptron_rat_eval], "K-Neighbors": [self.kneighbors_pol_eval, self.kneighbors_rat_eval], "Naive Bayes": [self.NB_pol_eval, self.NB_rat_eval], "SVM": [self.SVM_pol_eval, self.SVM_rat_eval], "Random Forest": [self.RF_pol_eval, self.RF_rat_eval], "NN (MLP)": [self.MLP_pol_eval, self.MLP_rat_eval], "Dummy (Baseline)": [self.Dummy_pol_eval, self.Dummy_rat_eval]}
+        self.__get_vocabulary()
+        self.__vectorizer_pol = pkl.load(open(self.__path + "vectorizer_pol.pkl", 'rb'))
+        self.__vectorizer_rat = pkl.load(open(self.__path + "vectorizer_rat.pkl", 'rb'))
+        self.__X_pol_test = pkl.load(open(self.__path + "X_pol_test.pkl", 'rb'))
+        self.__y_pol_test = pkl.load(open(self.__path + "y_pol_test.pkl", 'rb'))
+        self.__X_rat_test = pkl.load(open(self.__path + "X_rat_test.pkl", 'rb'))
+        self.__y_rat_test = pkl.load(open(self.__path + "y_rat_test.pkl", 'rb'))
+        self.__get_models()
+
+    def __get_models(self):
+        self.__perceptron_pol = pkl.load(open(self.__path + "perceptron_pol.pkl", 'rb'))
+        self.__perceptron_pol_score = self.__perceptron_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__perceptron_rat = pkl.load(open(self.__path + "perceptron_rat.pkl", 'rb'))
+        self.__perceptron_rat_score = self.__perceptron_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+        self.__rf_pol = pkl.load(open(self.__path + "rf_pol.pkl", 'rb'))
+        self.__rf_pol_score = self.__rf_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__rf_rat = pkl.load(open(self.__path + "rf_rat.pkl", 'rb'))
+        self.__rf_rat_score = self.__rf_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+        self.__nb_pol = pkl.load(open(self.__path + "nb_pol.pkl", 'rb'))
+        self.__nb_pol_score = self.__nb_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__nb_rat = pkl.load(open(self.__path + "nb_rat.pkl", 'rb'))
+        self.__nb_rat_score = self.__nb_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+        # self.__svm_pol = pkl.load(open(self.__path + "svm_pol.pkl", 'rb'))
+        # self.__svm_pol_score = self.__svm_pol.score(self.__X_pol_test, self.__y_pol_test)
+        # self.__svm_rat = pkl.load(open(self.__path + "svm_rat.pkl", 'rb'))
+        # self.__svm_rat_score = self.__svm_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+        self.__k_neighbors_pol = pkl.load(open(self.__path + "kneighbors_pol.pkl", 'rb'))
+        self.__k_neighbors_pol_score = self.__k_neighbors_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__k_neighbors_rat = pkl.load(open(self.__path + "kneighbors_rat.pkl", 'rb'))
+        self.__k_neighbors_rat_score = self.__k_neighbors_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+        self.__dummy_pol = pkl.load(open(self.__path + "dummy_pol.pkl", 'rb'))
+        self.__dummy_pol_score = self.__dummy_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__dummy_rat = pkl.load(open(self.__path + "dummy_rat.pkl", 'rb'))
+        self.__dummy_rat_score = self.__dummy_rat.score(self.__X_rat_test, self.__y_rat_test))
+
+        self.__clf_pol = pkl.load(open(self.__path + "clf_pol.pkl", 'rb'))
+        self.__clf_pol_score = self.__clf_pol.score(self.__X_pol_test, self.__y_pol_test)
+        self.__clf_rat = pkl.load(open(self.__path + "clf_rat.pkl", 'rb'))
+        self.__clf_rat_score = self.__clf_rat.score(self.__X_rat_test, self.__y_rat_test)
+
+    def perceptron_pol_eval(self, evalu):
+        tmp = self.__perceptron_pol.predict(evalu)
+        return([[tmp, 1-tmp]], str(self.__perceptron_pol_score))
+
+    def perceptron_rat_eval(self, evalu):
+        tmp = self.__perceptron_rat.predict(evalu)
+        if (tmp == 5):
+            tmp = [[0, 0, 0, 1]]
+        elif (tmp == 4):
+            tmp = [[0, 0, 1, 0]]
+        elif (tmp == 2):
+            tmp = [[0, 1, 0, 0]]
+        else:
+            tmp = [[1, 0, 0, 0]]
+        return(tmp, str(self.__perceptron_rat_score))
+
+    def kneighbors_pol_eval(self, evalu):
+        return(self.__k_neighbors_pol.predict_proba(evalu).tolist(), str(self.__k_neighbors_rat_score))
+
+    def kneighbors_rat_eval(self, evalu):
+        return(self.__k_neighbors_rat.predict_proba(evalu).tolist(), str(self.__k_neighbors_rat_score))
+
+    def NB_pol_eval(self, evalu):
+        return(self.__nb_pol.predict_proba(evalu).tolist(), str(self.__nb_pol_score))
+
+    def NB_rat_eval(self, evalu):
+        return(self.__nb_rat.predict_proba(evalu).tolist(), str(self.__nb_rat_score))
+
+    def SVM_pol_eval(self, evalu):
+        return(self.__svm_pol.predict_proba(evalu).tolist(), str(self.__svm_pol_score))
+
+    def SVM_rat_eval(self, evalu):
+        return(self.__svm_rat.predict_proba(evalu).tolist(), str(self.__svm_rat_score))
+
+    def RF_pol_eval(self, evalu):
+        return(self.__rf_pol.predict_proba(evalu).tolist(), str(self.__rf_pol_score))
+
+    def RF_rat_eval(self, evalu):
+        return(self.__rf_rat.predict_proba(evalu).tolist(), str(self.__rf_rat_score))
+
+    def MLP_pol_eval(self, evalu):
+        return(self.__clf_pol.predict_proba(evalu).tolist(), str(self.__clf_pol_score))
+
+    def MLP_rat_eval(self, evalu):
+        return(self.__clf_rat.predict_proba(evalu).tolist(), str(self.__clf_rat_score))
+
+    def Dummy_pol_eval(self, evalu):
+        return(self.__dummy_pol.predict_proba(evalu).tolist(), self.__dummy_pol_score)
+
+    def Dummy_rat_eval(self, evalu):
+        tmp = self.__dummy_rat.predict_proba(evalu).tolist()
+        return(tmp, self.__dummy_rat.score)
+
+    def __get_vocabulary(self):
+        with open("dataset/vocabulary_polarity.txt", "r") as o:
+            res = o.read()
+            self.__vocabulary = res.split("\n")
+            self.__vocabulary = list(set(self.__vocabulary))
+
+    def Tokenizer(self, text):
+        tmp = self.__vectorizer_pol.transform([text])
+        tmp = tmp.toarray()
+        return (tmp)
+
+    def Manage(self, model, Dataset, review):
+        if (Dataset == "Binary"):
+            percent, score = self.__exec[model][0](review)
+            res = pd.DataFrame({'Positive': percent[0][0], 'Negative': percent[0][1]}, index=["Prediction"])
+        else:
+            percent, score = self.__exec[model][1](review)
+            res = pd.DataFrame({'Rated 1/5': percent[0][0], 'Rated 2/5': percent[0][1], 'Rated 4/5': percent[0][2], 'Rated 5/5': percent[0][3]}, index=["Prediction"])
+
+        return (res, f"Model: {model}\nDataset: {Dataset}\nAccuracy: {str(float(score)*100)}")
+
+
+if __name__ == "__main__":
+    class Execution:
+        def __init__(self):
+            self.__n = NLP()
+
+        def greet(self, Model, Dataset, Review):
+            return(self.__n.Manage(Model, Dataset, self.__n.Tokenizer(Review)))
+
+    e = Execution()
+    gr.Interface(e.greet, [gr.inputs.Dropdown(["Perceptron", "K-Neighbors", "Naive Bayes", "SVM", "Random Forest", "NN (MLP)", "Dummy (Baseline)"]), gr.inputs.Dropdown(["Binary", "Rating"]), "text"], [gr.outputs.Dataframe(), "text"]).launch()