Update app.py

app.py

@@ -1,4 +1,190 @@
 import streamlit as st
+import joblib
+import pickle
+import pandas as pd
+import nltk
+#nltk.download('stopwords')
+from nltk.corpus import stopwords
+#nltk.download('punkt')
+from nltk.tokenize import punkt
+#nltk.download('wordnet')
+from nltk.corpus.reader import wordnet
+#nltk.download('WordNetLemmatizer')
+from nltk.stem import WordNetLemmatizer
+from sklearn.feature_extraction.text import TfidfVectorizer
+import spacy
+import matplotlib as plt
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x * x)
+
+def main():
+    """ Blooms Taxonomy classifier"""
+
+    st.title("Blooms Taxonomy Classifier")
+    st.subheader("ML App for Blooms Taxonomy Level Prediction")
+    
+    activities = ["Prediction","About"]
+    choice =st.sidebar.selectbox("Choose Activity",activities )
+   
+    if choice == "Prediction":
+        path_tfidf = "tfidf.pickle"
+                
+        with open(path_tfidf, 'rb') as data:
+            tfidf = pickle.load(data)
+        category_codes = {
+                           'BT1 - Knowledge': 0,
+                           'BT2 - Comprehension': 1,
+                           'BT3 - Application': 2,
+                           'BT4 - Analysis': 3,
+                           'BT5 - Evaluation': 4,
+                           'BT6 - Creation': 5
+                           }
+
+        punctuation_signs = list("?:!.,;")
+        stop_words = list(stopwords.words('english'))
+
+        def create_features_from_text(text):
+    
+                      # Dataframe creation
+            lemmatized_text_list = []
+            df = pd.DataFrame(columns=['Questions'])
+            df.loc[0] = text
+            df['Questions_Parsed_1'] = df['Questions'].str.replace("\r", " ")
+            df['Questions_Parsed_1'] = df['Questions_Parsed_1'].str.replace("\n", " ")
+            df['Questions_Parsed_1'] = df['Questions_Parsed_1'].str.replace("    ", " ")
+            df['Questions_Parsed_1'] = df['Questions_Parsed_1'].str.replace('"', '')
+            df['Questions_Parsed_2'] = df['Questions_Parsed_1'].str.lower()
+            df['Questions_Parsed_3'] = df['Questions_Parsed_2']
+            for punct_sign in punctuation_signs:
+                df['Questions_Parsed_3'] = df['Questions_Parsed_3'].str.replace(punct_sign, '')
+            df['Questions_Parsed_4'] = df['Questions_Parsed_3'].str.replace("'s", "")
+            wordnet_lemmatizer = WordNetLemmatizer()
+            lemmatized_list = []
+            text = df.loc[0]['Questions_Parsed_4']
+            text_words = text.split(" ")
+            for word in text_words:
+                lemmatized_list.append(wordnet_lemmatizer.lemmatize(word, pos="v"))
+            lemmatized_text = " ".join(lemmatized_list)    
+            lemmatized_text_list.append(lemmatized_text)
+            df['Questions_Parsed_5'] = lemmatized_text_list
+            df['Questions_Parsed_6'] = df['Questions_Parsed_5']
+            for stop_word in stop_words:
+                regex_stopword = r"\b" + stop_word + r"\b"
+                df['Questions_Parsed_6'] = df['Questions_Parsed_6'].str.replace(regex_stopword, '')
+            df = df['Questions_Parsed_6']
+            df = df.rename({'Questions_Parsed_6': 'Questions_Parsed'})
+    
+            # TF-IDF
+            features = tfidf.transform(df).toarray()
+    
+            return features
+                
+        def get_category_name(category_id):
+            for category, id_ in category_codes.items():    
+                if id_ == category_id:
+                    return category                
+        def predict_from_text(text):
+            path_lr = 'best_lrc.pickle'
+            with open(path_lr, 'rb') as data:
+                lr_model = pickle.load(data)
+
+            path_mnb = 'best_mnbc.pickle'
+            with open(path_mnb, 'rb') as data:
+                mnb_model = pickle.load(data)
+
+            path_gbc = 'best_gbc.pickle'
+            with open(path_gbc, 'rb') as data:
+                gbc_model = pickle.load(data)
+
+            path_rfc = 'best_rfc.pickle'
+            with open(path_rfc, 'rb') as data:
+                rfc_model = pickle.load(data)
+
+            path_knn = 'best_knnc.pickle'
+            with open(path_knn, 'rb') as data:
+                knn_model = pickle.load(data)
+
+            path_svm = 'best_svc.pickle'
+            with open(path_svm, 'rb') as data:
+                svc_model = pickle.load(data)
+    
+                   # Predict using the input model
+            prediction_lr = lr_model.predict(create_features_from_text(text))[0]
+            prediction_lr_proba = lr_model.predict_proba(create_features_from_text(text))[0]
+            prediction_mnb = mnb_model.predict(create_features_from_text(text))[0]
+            prediction_mnb_proba = mnb_model.predict_proba(create_features_from_text(text))[0]
+            prediction_gbc = gbc_model.predict(create_features_from_text(text))[0]
+            prediction_gbc_proba = gbc_model.predict_proba(create_features_from_text(text))[0]
+            prediction_rfc = rfc_model.predict(create_features_from_text(text))[0]
+            prediction_rfc_proba = svc_model.predict_proba(create_features_from_text(text))[0]
+            prediction_knn = knn_model.predict(create_features_from_text(text))[0]
+            prediction_knn_proba = svc_model.predict_proba(create_features_from_text(text))[0]
+            prediction_svc = svc_model.predict(create_features_from_text(text))[0]
+            prediction_svc_proba = svc_model.predict_proba(create_features_from_text(text))[0]
+    
+                    # Return result
+            category_lr = get_category_name(prediction_lr)
+            category_mnb = get_category_name(prediction_mnb)
+            category_gbc = get_category_name(prediction_gbc)
+            category_rfc = get_category_name(prediction_rfc)
+            category_knn = get_category_name(prediction_knn)
+            category_svc = get_category_name(prediction_svc)
+            a=prediction_lr_proba.max()*100
+            b=prediction_mnb_proba.max()*100
+            c=prediction_gbc_proba.max()*100
+            d=prediction_rfc_proba.max()*100
+            e=prediction_knn_proba.max()*100
+            f=prediction_svc_proba.max()*100
+            best_one = {"category_lr":prediction_lr_proba.max()*100,"category_mnb":prediction_mnb_proba.max()*100,"category_gbc":prediction_gbc_proba.max()*100,"category_rfc":prediction_rfc_proba.max()*100,"category_knn":prediction_knn_proba.max()*100,"category_svc":prediction_svc_proba.max()*100}
+            keymax = max(best_one, key = best_one.get)
+            if keymax == "category_lr":
+                return category_lr, best_one["category_lr"],a,b,c,d,e,f
+            elif keymax == "category_mnb":
+                return category_mnb,best_one["category_mnb"],a,b,c,d,e,f
+            elif keymax == "category_gbc":
+                return category_gbc,best_one["category_gbc"],a,b,c,d,e,f
+            elif keymax == "category_rfc":
+                return category_rfc,best_one["category_rfc"],a,b,c,d,e,f
+            elif keymax == "category_knn":
+                return category_knn,best_one["category_knn"],a,b,c,d,e,f
+            else:
+                return category_svc,best_one["category_svc"],a,b,c,d,e,f
+
+    
+        
+        st.info("Prediction with Various Models")
+        
+        bt_text = st.text_area("Question to Predict","Typer Here")
+
+        if st.button("Classify"):
+            st.text("Original Text ::\n{}".format(bt_text))
+          
+
+
+            prediction = predict_from_text(bt_text)
+
+            st.success("Blooms Taxonomy Level   ::   {}".format(prediction[0]))
+            st.success("Maximum Probability   ::   {}".format(prediction[1]))
+            st.write("Performance of Various Algorithms")
+
+            data = pd.DataFrame({
+                'Various Algorithm': ['Logistic Regression', 'Multinomial Naive Bayes', 'Gradient Boosting Classifier','Random Forest Classifier','k-Nearest Neighbors','Support Vector Machine'],
+                'Maximum Accuracy': [(prediction[2]),prediction[3],prediction[4],prediction[5],prediction[6],prediction[7]],
+            }).set_index('Various Algorithm')
+
+            st.write(data)
+            st.bar_chart(data)
+
+
+
+    if choice == "About":
+        st.success("This web app is developed by Vijay Devane.")
+hide_streamlit_style = """
+            <style>
+            #MainMenu {visibility: hidden;}
+            footer {visibility: hidden;}
+            </style>
+            """
+st.markdown(hide_streamlit_style, unsafe_allow_html=True) 
+
+if __name__ =='__main__':
+    main()