Upload 15 files

BackPropogation1.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,46 @@
+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
+
+
+    
+    
+    
+ 

app.py

@@ -0,0 +1,159 @@
+import pickle
+import numpy as np 
+import streamlit as  st 
+import cv2
+import tensorflow as tf
+from tqdm import tqdm 
+from PIL import Image
+import os 
+from tensorflow.keras.preprocessing import sequence
+
+st.title("DL-Classifier")
+
+task1 = st.selectbox('Select One',("Choose any","Sentiment Classification", 'Tumor Detection'))
+
+
+#choosing tumor detection
+#CNN
+if task1=="Tumor Detection":
+     st.subheader("Tumor Detection")
+     with open("tumor_detection_model.pkl", "rb") as model_file:
+        cnn_model = pickle.load(model_file)
+
+     img =st.file_uploader("choose the image",type=('jpg','jpeg','png'))
+     def cnn_make_prediction(img,cnn_model):
+            img=Image.open(img)
+            img=img.resize((128,128))
+            img=np.array(img)
+            input_img = np.expand_dims(img, axis=0)
+            res = cnn_model.predict(input_img)
+            if res:
+                return"Tumor"
+            else:
+               return"No Tumor"
+     if img != None:
+         img_f="D:/SEM 3/DL/DL-ALGORITHMS/CNN/tumor_detection/tumordata/pred/"
+         img_p=img_f + img.name
+         pred=cnn_make_prediction(img_p,cnn_model)
+         st.write(pred)
+         
+
+#choosing classification
+
+
+if task1=="Sentiment Classification":
+     st.subheader("Sentiment Classification")
+     clss_model= st.radio("Select Classification Model:",("RNN","DNN","Backpropagation",'Perceptron','LSTM'))
+     select_model=None
+
+     if clss_model=="RNN":
+          with open("rnn_model.pkl",'rb') as model_file:
+               rnn_model=pickle.load(model_file)
+          with open("rnn_tokeniser.pkl",'rb') as tokeniser_file:
+                rnn_tokeniser=pickle.load(tokeniser_file)
+                
+                st.subheader('Spam Classification')
+                
+                input=st.text_input("Enter your message here:")
+                def rnn_pred(input):
+                    max_length=10
+                    encoded_test = rnn_tokeniser.texts_to_sequences(input)
+                    padded_test = tf.keras.preprocessing.sequence.pad_sequences(encoded_test, maxlen=max_length, padding='post') 
+                    predict= (rnn_model.predict(padded_test) > 0.5).astype("int32")
+                    if predict:
+                         return "Spam "
+                    else: 
+                         return "Not Spam"        
+                if st.button('Check'):
+                    pred=rnn_pred([input]) 
+                    st.write(pred)
+
+     if clss_model=='Perceptron':
+          with open("perceptron_model_saved.pkl",'rb') as model_file:
+               percep_model=pickle.load(model_file)
+          with open('perceptron_tokeniser_saved.pkl','rb') as model_file:
+               percep_token=pickle.load(model_file)
+          st.subheader('Spam Classification')
+          input= st.text_input("Enter your text here")
+
+          def percep_pred(input):
+               encoded_test_p = percep_token.texts_to_sequences([input])
+               padded_test_p = tf.keras.preprocessing.sequence.pad_sequences(encoded_test_p, maxlen=10) 
+               predict_p= percep_model.predict(padded_test_p)
+               if predict_p:
+                    return "Spam"
+               else:
+                    return "Not Spam"
+          if st.button("Check"):
+               percep_pred([input])
+
+     
+     if clss_model=="Backpropagation":
+          with open('backprop_model.pkl','rb') as model_file:
+               bp_model=pickle.load(model_file)
+          with open('backrpop_tokeniser.pkl','rb') as model_file:
+               bp_tokeniser=pickle.load(model_file)
+          st.subheader('Spam Classification')
+          input= st.text_input("Enter your text here")
+          
+          
+          def back_pred(input):
+               encoded_test = bp_tokeniser.texts_to_sequences([input])
+               padded_test = tf.keras.preprocessing.sequence.pad_sequences(encoded_test, maxlen=10) 
+               predict= bp_model.predict(padded_test)
+               if predict:
+                    return "Spam"
+               else:
+                    return "Not Spam"
+          if st.button("Check"):
+               back_pred([input])
+
+     if clss_model=="DNN":
+          with open("dnn_model.pkl",'rb') as file:
+               dnn_model=pickle.load(file) 
+
+          with open("dnn_tokeniser.pkl",'rb') as file:
+               dnn_tokeniser=pickle.load(file)
+          st.subheader('Spam Classification')
+          input= st.text_input("Enter your text here")
+
+          def dnn_pred(input):
+               encoded_test = dnn_tokeniser.texts_to_sequences([input])
+               padded_test = tf.keras.preprocessing.sequence.pad_sequences(encoded_test, maxlen=500) 
+               predict= dnn_model.predict(padded_test)
+               if predict:
+                    return "Spam"
+               else:
+                    return "Not Spam"
+          if st.button('Check'):
+                    pred=dnn_pred([input]) 
+                    st.write(pred)
+         
+     
+     if clss_model=="LSTM":
+          with open("lstm_model.pkl",'rb') as file:
+               lstm_model=pickle.load(file) 
+
+          with open("lstm_tokeniser.pkl",'rb') as file:
+               lstm_tokeniser=pickle.load(file)
+          st.subheader('Movie Review Classification')
+          inp=st.text_area("Enter your review")
+          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)
+               
+
+
+                
+
+            

backprop_model.pkl

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

backrpop_tokeniser.pkl

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

dnn_model.pkl

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

dnn_tokeniser.pkl

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

lstm_model.pkl

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

lstm_tokeniser.pkl

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

perceptron_model_saved.pkl

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

perceptron_tokeniser_saved.pkl

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

rnn_model.pkl

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

rnn_tokeniser.pkl

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

tumor_detection_model.pkl

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