Upload 17 files

BackPropogation.py

@@ -0,0 +1,53 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class BackPropogation:
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+    def fit(self, X, y):
+        error_sum=0
+        n_features = X.shape[1]
+        self.weights = np.zeros((n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+                
+                # Calculating loss and updating weights.
+                error = target - prediction
+                self.weights += self.learning_rate * error * inputs
+                self.bias += self.learning_rate * error
+                
+            print(f"Updated Weights after epoch {epoch} with {self.weights}")
+        print("Training Completed")
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

Perceptron.py

@@ -0,0 +1,48 @@
+import numpy as np
+from tqdm import tqdm
+
+
+class Perceptron:
+    
+    def __init__(self,learning_rate=0.01, epochs=100,activation_function='step'):
+        self.bias = 0
+        self.learning_rate = learning_rate
+        self.max_epochs = epochs
+        self.activation_function = activation_function
+
+
+    def activate(self, x):
+        if self.activation_function == 'step':
+            return 1 if x >= 0 else 0
+        elif self.activation_function == 'sigmoid':
+            return 1 if (1 / (1 + np.exp(-x)))>=0.5 else 0
+        elif self.activation_function == 'relu':
+            return 1 if max(0,x)>=0.5 else 0
+
+
+    def fit(self, X, y):
+        n_features = X.shape[1]
+        self.weights = np.random.randint(n_features, size=(n_features))
+        for epoch in tqdm(range(self.max_epochs)):
+            for i in range(len(X)):
+                inputs = X[i]
+                target = y[i]
+                weighted_sum = np.dot(inputs, self.weights) + self.bias
+                prediction = self.activate(weighted_sum)
+        print("Training Completed")
+
+
+    def predict(self, X):
+        predictions = []
+        for i in range(len(X)):
+            inputs = X[i]
+            weighted_sum = np.dot(inputs, self.weights) + self.bias
+            prediction = self.activate(weighted_sum)
+            predictions.append(prediction)
+        return predictions
+
+
+    
+    
+    
+ 

README.md

@@ -1,10 +1,10 @@
 ---
-title: Multi Model Classifier
-emoji: 🏢
-colorFrom: gray
-colorTo: red
+title: Nn Models
+emoji: 🌍
+colorFrom: pink
+colorTo: green
 sdk: streamlit
-sdk_version: 1.29.0
+sdk_version: 1.28.2
 app_file: app.py
 pinned: false
 ---

app.py

@@ -0,0 +1,159 @@
+import streamlit as st
+import pickle
+import tensorflow as tf
+from tensorflow.keras.preprocessing import sequence
+from tensorflow.keras.saving import load_model
+import numpy as np
+import cv2
+from PIL import Image
+
+
+st.title('Deep Learning Classifier App')
+task = st.selectbox('Select Task', ['Choose one','Sentiment Classification', 'Tumor Detection'])
+
+if task=='Tumor Detection':
+    st.subheader('Tumor Detection with CNN')
+    # CNN
+    cnn_model = load_model("cnn_model.h5")
+
+    img = st.file_uploader('Upload image', type=['jpeg', 'jpg', 'png'])
+
+    def cnn_make_prediction(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"Tumor Detected"
+        else:
+            return"No Tumor Detected"
+                
+    if img is not None:
+        st.image(img, caption = "Image preview")
+        if st.button('Submit'):
+            pred = cnn_make_prediction(img, 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("ppn_model.pkl",'rb') as file:
+            perceptron = pickle.load(file)
+        with open("ppn_tokeniser.pkl",'rb') as file:
+            ppn_tokeniser = pickle.load(file)
+
+        st.subheader('Movie Review Classification using Perceptron')
+        inp = st.text_area('Enter message')
+        
+        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"       
+        
+        if st.button('Check'):
+            pred = ppn_make_predictions([inp], perceptron)
+            st.write(pred)
+
+    elif arc == arcs[1]:
+        # BackPropogation
+        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)
+
+        st.subheader('Movie Review Classification using Backpropagation')
+        inp = st.text_area('Enter message')
+        
+        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"        
+        
+        if st.button('Check'):
+            pred = bp_make_predictions([inp], backprop)
+            st.write(pred)
+
+
+    elif arc == arcs[2]:
+        # DNN
+        dnn_model = load_model("dnn_model.h5")
+        with open("dnn_tokeniser.pkl",'rb') as file:
+            dnn_tokeniser = pickle.load(file)
+
+        st.subheader('SMS Spam Classification using DNN')
+        inp = st.text_area('Enter message')
+        
+        def dnn_make_predictions(inp, model):
+            encoded_inp = dnn_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"     
+        
+        if st.button('Check'):
+            pred = dnn_make_predictions([inp], dnn_model)
+            st.write(pred)
+
+
+    elif arc == arcs[3]:
+        # RNN 
+        rnn_model = load_model("rnn_model.h5") 
+
+        with open("rnn_tokeniser.pkl",'rb') as file:
+            rnn_tokeniser = pickle.load(file)
+
+        st.subheader('SMS Spam Classification using RNN')
+        inp = st.text_area('Enter message')
+        
+        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"
+
+
+        if st.button('Check'):
+            pred = rnn_make_predictions([inp], rnn_model)
+            st.write(pred)
+    
+
+    elif arc == arcs[4]:
+        # LSTM
+        lstm_model = load_model("lstm_model.h5") 
+
+        with open("lstm_tokeniser.pkl",'rb') as file:
+            lstm_tokeniser = pickle.load(file)
+
+        st.subheader('Movie Review Classification using LSTM')
+        inp = st.text_area('Enter message')
+
+        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"
+
+        if st.button('Check'):
+            pred = lstm_make_predictions([inp], lstm_model)
+            st.write(pred)  

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:09ac51e8d69f97cb4b0756b2be644b509c9798371fbf469b378369548b5d0e21
+size 4992453

cnn_model.h5

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

dnn_model.h5

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

dnn_tokeniser.pkl

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

lstm_model.h5

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

lstm_tokeniser.pkl

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

ppn_model.pkl

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

ppn_tokeniser.pkl

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

requirements.txt

@@ -0,0 +1,7 @@
+tensorflow==2.13.0
+numpy==1.23.5
+opencv-python==4.8.1.78
+Pillow==9.3.0
+streamlit==1.26.0
+requires.io
+

rnn_model.h5

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

rnn_tokeniser.pkl

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