Update app.py

app.py

@@ -1,154 +1,144 @@
+import pandas as pd
 import streamlit as st
-import pickle
-import tensorflow as tf
-from tensorflow.keras.preprocessing import sequence
 import numpy as np
-import cv2
+import tensorflow as tf
 from PIL import Image
+import pickle
 
 
-st.title('Classifier')
-task = st.selectbox('Select Task', ['Choose one','Sentiment Classification', 'Tumor Detection'])
-
-if task=='Tumor Detection':
-    st.subheader('Tumor Detection with CNN')
-    # CNN
-    cnn_model = tf.keras.models.load_model("cnn_model.h5")
-
-    def cnn_make_prediction(img,model):
-        img=cv2.imread(img)
-        img=Image.fromarray(img)
-        img=img.resize((128,128))
-        img=np.array(img)
-        input_img = np.expand_dims(img, axis=0)
-        res = model.predict(input_img)
-        if res:
-            return "Tumor Detected"
-        else:
-            return "No Tumor Detected"
-        
-    img = st.file_uploader('Upload image', type=['jpeg', 'jpg', 'png'])
-    if img!=None:
-        img_folder = "data/tumordata/pred/"
-        img_path = img_folder+img.name
-        st.image(img_path, caption = "Image preview")
-        if st.button('Submit'):
-            pred = cnn_make_prediction(img_path, cnn_model)
-            st.write(pred)
-
-
-if task=='Sentiment Classification':
-    arcs = ['Perceptron', 'Backpropagation', 'DNN', 'RNN', 'LSTM']
-    arc = st.radio('Pick one:', arcs, horizontal=True)
-
-    if arc == arcs[0]:
-        # Perceptron
-        with open("models/pickles/ppn_model.pkl",'rb') as file:
-            perceptron = pickle.load(file)
-        with open("models/pickles/ppn_tokeniser.pkl",'rb') as file:
-            ppn_tokeniser = pickle.load(file)
-
-        def ppn_make_predictions(inp, model):
-            encoded_inp = ppn_tokeniser.texts_to_sequences([inp])
-            padded_inp = sequence.pad_sequences(encoded_inp, maxlen=500)
-            res = model.predict(padded_inp)
-            if res:
-                return "Negative"
-            else:
-                return "Positive"       
-        
-        st.subheader('Movie Review Classification using Perceptron')
-        inp = st.text_area('Enter message')
-        if st.button('Check'):
-            pred = ppn_make_predictions([inp], perceptron)
-            st.write(pred)
-
-    elif arc == arcs[1]:
-        # BackPropogation
-        with open("models/pickles/bp_model.pkl",'rb') as file:
-            backprop = pickle.load(file)
-        with open("models/pickles/bp_tokeniser.pkl",'rb') as file:
-            bp_tokeniser = pickle.load(file)
-
-        def bp_make_predictions(inp, model):
-            encoded_inp = bp_tokeniser.texts_to_sequences([inp])
-            padded_inp = sequence.pad_sequences(encoded_inp, maxlen=500)
-            res = model.predict(padded_inp)
-            if res:
-                return "Negative"
-            else:
-                return "Positive"        
-        
-        st.subheader('Movie Review Classification using Backpropagation')
-        inp = st.text_area('Enter message')
-        if st.button('Check'):
-            pred = bp_make_predictions([inp], backprop)
-            st.write(pred)
-
-
-    elif arc == arcs[2]:
-        # DNN
-        dnn_model = tf.keras.models.load_model("dnn_model.h5")
-        with open("models/pickles/dnn_tokeniser.pkl",'rb') as file:
-            dnn_tokeniser = pickle.load(file)
-
-        def dnn_make_predictions(inp, model):
-            inp = dnn_tokeniser.texts_to_sequences(inp)
-            inp = sequence.pad_sequences(inp, maxlen=500)
-            res = (model.predict(inp) > 0.5).astype("int32")
-            if res:
-                return "Negative"
-            else:
-                return "Positive"       
-        
-        st.subheader('Movie Review Classification using DNN')
-        inp = st.text_area('Enter message')
-        if st.button('Check'):
-            pred = dnn_make_predictions([inp], dnn_model)
-            st.write(pred)
-
-
-    elif arc == arcs[3]:
-        # RNN 
-        rnn_model = tf.keras.models.load_model("rnn_model.h5") 
+st.header('Demo')
+task = st.selectbox('Select Task', ["Select One",'Sentiment Classification', 'Tumor Detection'])
 
-        with open("models/pickles/rnn_tokeniser.pkl",'rb') as file:
-            rnn_tokeniser = pickle.load(file)
 
-        def rnn_make_predictions(inp, model):
-            encoded_inp = rnn_tokeniser.texts_to_sequences(inp)
-            padded_inp = sequence.pad_sequences(encoded_inp, maxlen=10, padding='post')
-            res = (model.predict(padded_inp) > 0.5).astype("int32")
+if task == "Tumor Detection":
+        def cnn(img, model):
+            img = Image.open(img)
+            img = img.resize((128, 128))
+            img = np.array(img)
+            input_img = np.expand_dims(img, axis=0)
+            res = model.predict(input_img)
             if res:
-                return "Spam"
+                return "Tumor Detected"
             else:
-                return "Ham"
-
-        st.subheader('SMS Spam Classification using RNN')
-        inp = st.text_area('Enter message')
-        if st.button('Check'):
-            pred = rnn_make_predictions([inp], rnn_model)
-            st.write(pred)
-    
-
-    elif arc == arcs[4]:
-        # LSTM
-        lstm_model = tf.keras.models.load_model("lstm_model.h5") 
-
-        with open("models/pickles/lstm_tokeniser.pkl",'rb') as file:
-            lstm_tokeniser = pickle.load(file)
-
-        def lstm_make_predictions(inp, model):
-            inp = lstm_tokeniser.texts_to_sequences(inp)
-            inp = sequence.pad_sequences(inp, maxlen=500)
-            res = (model.predict(inp) > 0.5).astype("int32")
-            if res:
-                return "Negative"
-            else:
-                return "Positive"
+                return "No Tumor" 
+            
+        cnn_model = tf.keras.models.load_model("cnn_model.h5")
+        uploaded_file = st.file_uploader("Choose a file", type=["jpg", "jpeg", "png"])
+        if uploaded_file is not None:
+            st.image(uploaded_file, caption="Uploaded Image", use_column_width=True)
+            if st.button("Submit"):
+                result=cnn(uploaded_file, cnn_model)
+                st.write(result)
+
+        
+elif task == "Sentiment Classification":
+        types = ["Perceptron","BackPropagation", "RNN","DNN", "LSTM"]
+        input_text2 = st.radio("Select", types, horizontal=True)
+
+        if input_text2 == "Perceptron":
+                with open("ppn_model.pkl",'rb') as file:
+                    perceptron = pickle.load(file)
+                with open("ppn_tokeniser.pkl",'rb') as file:
+                    ppn_tokeniser = pickle.load(file)
+
+                def ppn_make_predictions(inp, model):
+                    encoded_inp = ppn_tokeniser.texts_to_sequences([inp])
+                    padded_inp = tf.keras.preprocessing.sequence.pad_sequences(encoded_inp, maxlen=500)
+                    res = model.predict(padded_inp)
+                    if res:
+                        return "Negative"
+                    else:
+                        return "Positive"       
+                
+                st.subheader('Movie Review Classification using Perceptron')
+                inp = st.text_area('Enter message')
+                if st.button('Check'):
+                    pred = ppn_make_predictions([inp], perceptron)
+                    st.write(pred)
+
+        if input_text2 == "BackPropagation":
+                with open("bp_model.pkl",'rb') as file:
+                    backprop = pickle.load(file)
+                with open("bp_tokeniser.pkl",'rb') as file:
+                    bp_tokeniser = pickle.load(file)
+
+                def bp_make_predictions(inp, model):
+                    encoded_inp = bp_tokeniser.texts_to_sequences([inp])
+                    padded_inp = tf.keras.preprocessing.sequence.pad_sequences(encoded_inp, maxlen=500)
+                    res = model.predict(padded_inp)
+                    if res:
+                        return "Negative"
+                    else:
+                        return "Positive"     
+                       
+                st.subheader('Movie Review Classification using BackPropagation')
+                inp = st.text_area('Enter message')
+                if st.button('Check'):
+                    pred = bp_make_predictions([inp], backprop)
+                    st.write(pred)
+        
 
-        st.subheader('Movie Review Classification using LSTM')
-        inp = st.text_area('Enter message')
-        if st.button('Check'):
-            pred = lstm_make_predictions([inp], lstm_model)
-            st.write(pred)  
+        elif input_text2 == "RNN":
+                rnn_model=tf.keras.models.load_model("rnn_model.h5")
+                with open("rnn_tokeniser.pkl", 'rb') as model_file:
+                    rnn_tokeniser=pickle.load(model_file)
+
+                def rnn_make_predictions(inp, model):
+                    encoded_inp = rnn_tokeniser.texts_to_sequences([inp])
+                    padded_inp = tf.keras.preprocessing.sequence.pad_sequences(encoded_inp, maxlen=10, padding='post')
+                    res = (model.predict(padded_inp) > 0.5).astype("int32")
+                    if res:
+                        return "Spam"
+                    else:
+                        return "Ham"
+
+                st.subheader('Spam message Classification using RNN')
+                input = st.text_area("Give message")
+                if st.button('Check'):
+                    pred = rnn_make_predictions([input], rnn_model)
+                    st.write(pred)
+
+
+
+        elif input_text2 == "DNN":
+                        dnn_model=tf.keras.models.load_model("dnn_model.h5")
+                        with open("dnn_tokeniser.pkl",'rb') as file:
+                            dnn_tokeniser = pickle.load(file)
+
+                        def dnn_make_predictions(inp, model):
+
+                            inp = dnn_tokeniser.texts_to_sequences([inp])
+                            inp = tf.keras.preprocessing.sequence.pad_sequences(inp, maxlen=500)
+                            res = model.predict([inp]) 
+                            if res:
+                                return "Negative"
+                            else:
+                                return "Positive"       
+                        
+                        st.subheader('Movie Review Classification using DNN')
+                        inp = st.text_area('Enter message')
+                        if st.button('Check'):
+                            pred = dnn_make_predictions([inp], dnn_model)
+                            st.write(pred)
+
+                            
+
+        elif input_text2 == "LSTM":
+                lstm_model=tf.keras.models.load_model("lstm_model.h5")
+
+                with open("lstm_tokeniser.pkl",'rb') as file:
+                    lstm_tokeniser = pickle.load(file)
+
+                def lstm_make_predictions(inp, model):
+                    inp = lstm_tokeniser.texts_to_sequences([inp])
+                    inp = tf.keras.preprocessing.sequence.pad_sequences(inp, maxlen=500)
+                    res = (model.predict(inp) > 0.5).astype("int32")
+                    if res:
+                        return "Negative"
+                    else:
+                        return "Positive"
+                st.subheader('Movie Review Classification using LSTM')
+                inp = st.text_area('Enter message')
+                if st.button('Check'):
+                    pred = lstm_make_predictions([inp], lstm_model)
+                    st.write(pred)