Upload 12 files

bp_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2898ac4c9ef15f477f4bd8ac49b1ae1357b92e6d8867b14c0b05ec7a4ea45149
+size 4300

bp_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68c56c0afcd4c13ccac291859cf6bb44f4c78f9378c6a1f6bd9b9f313cd8e580
+size 4992453

cnn_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c77c24c8acdd3de3dd04e80b3fe114bdc1eec826538b713ab0c2a3400bab2be
+size 391811360

dnn_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48e62d61e3e53722cfb1181a65fa4ad9b1d5d54c2da34f7ed881064504916ca6
+size 457224

dnn_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc21bf90fe1bf134b8ade78b93d6e14238875adf7f954e47231ff9f6a0d1bb3e
+size 4534143

lstm_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:207aec2713ec6e86fa02a2f7bc5b1e042bf241e2af26b76fb2a80c5cf0702921
+size 41224696

lstm_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1de484d6fe87bf8b6844fb66beab45096d8933e4b6a55ed40118dd82e1b19a8
+size 4534143

ppn_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62fe7b6a7005d5c06fcce7f72252bebca37c3ad923f1ec6555e94388b95bd4ca
+size 2267

ppn_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32ed1024acf49a6d96a40d5d938c340054302c09f3533f3d3e572a62df9c3719
+size 4848716

rnn_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72eec6a6bfe021e27843b74245abea60c295188e1913e1af54aa7564ef02e7b0
+size 2243672

rnn_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0046c6215e32d084977d5b2aca73448f0fd33d7726be036a8d5e46a5796d59a6
+size 287385

st.py

@@ -0,0 +1,154 @@
+import streamlit as st
+import pickle
+import tensorflow as tf
+from tensorflow.keras.preprocessing import sequence
+import numpy as np
+import cv2
+from PIL import Image
+
+
+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") 
+
+        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 res:
+                return "Spam"
+            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"
+
+        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)