Upload 21 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,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
+
+
+    
+    
+    
+ 

backpropogation_.py

@@ -0,0 +1,31 @@
+from sklearn.model_selection import train_test_split
+import pandas as pd
+import tensorflow as tf
+from tensorflow.keras.preprocessing import sequence
+from BackPropogation import BackPropogation
+import pickle
+
+dataset = pd.read_csv(r"IMDB Dataset.csv")
+
+dataset['sentiment'] = dataset['sentiment'].map( {'negative': 1, 'positive': 0} )
+X = dataset['review'].values
+y = dataset['sentiment'].values
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15, random_state=42)
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+tokeniser.fit_on_texts(X_train)
+X_train = tokeniser.texts_to_sequences(X_train)
+X_test = tokeniser.texts_to_sequences(X_test)
+
+max_review_length = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
+X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
+
+backprop = BackPropogation(learning_rate=0.01, epochs=5, activation_function='sigmoid')
+backprop.fit(X_train, y_train)
+pred = backprop.predict(X_test)
+
+with open("bp_model.pkl",'wb') as file:
+    pickle.dump(backprop, file) 
+with open("bp_tokeniser.pkl",'wb') as file:
+    pickle.dump(tokeniser, file) 

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:25c055c7c91a7c5d0afa96ed3f102e256329c9b6dca921ec2021a7c19c9993bf
+size 4992453

cnn_tumor.py

@@ -0,0 +1,60 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import os
+import tensorflow as tf
+from PIL import Image
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm
+import pickle
+
+image_dir = r"tumordataset\tumordata"
+no_tumor_images = os.listdir(image_dir + '/no')
+yes_tumor_images = os.listdir(image_dir + '/yes')
+
+dataset = []
+label = []
+img_siz = (128, 128)
+
+for i, image_name in tqdm(enumerate(no_tumor_images), desc="No Tumor"):
+    if image_name.split('.')[1] == 'jpg':
+        image = cv2.imread(image_dir + '/no/' + image_name)
+        image = Image.fromarray(image, 'RGB')
+        image = image.resize(img_siz)
+        dataset.append(np.array(image))
+        label.append(0)
+
+for i, image_name in tqdm(enumerate(yes_tumor_images), desc="Tumor"):
+    if image_name.split('.')[1] == 'jpg':
+        image = cv2.imread(image_dir + '/yes/' + image_name)
+        image = Image.fromarray(image, 'RGB')
+        image = image.resize(img_siz)
+        dataset.append(np.array(image))
+        label.append(1)
+
+dataset = np.array(dataset)
+label = np.array(label)
+
+x_train, x_test, y_train, y_test = train_test_split(dataset, label, test_size=0.2, random_state=42)
+
+x_train = tf.keras.utils.normalize(x_train, axis=1)
+x_test = tf.keras.utils.normalize(x_test, axis=1)
+
+model = tf.keras.models.Sequential([
+    tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),
+    tf.keras.layers.MaxPooling2D((2, 2)),
+    tf.keras.layers.Flatten(),
+    tf.keras.layers.Dense(256, activation='relu'),
+    tf.keras.layers.Dropout(.5),
+    tf.keras.layers.Dense(512, activation='relu'),
+    tf.keras.layers.Dense(1, activation='sigmoid')
+])
+model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
+history = model.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.1)
+
+model.save("tumor_detection_model.h5")
+
+with open("tumor_detection_model.pkl", "wb") as model_file:
+    pickle.dump(model, model_file)
+
+

dnn_main.py

@@ -0,0 +1,50 @@
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import train_test_split
+from numpy import argmax
+import tensorflow as tf
+from tensorflow.keras import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.preprocessing import sequence
+from tensorflow.keras.models import save_model
+from tensorflow.keras.preprocessing.text import Tokenizer
+import pickle
+
+dataset = pd.read_csv(r"IMDB Dataset.csv")
+
+dataset['sentiment'] = dataset['sentiment'].map( {'negative': 1, 'positive': 0} )
+X = dataset['review'].values
+y = dataset['sentiment'].values
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,random_state=42)
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+tokeniser.fit_on_texts(X_train)
+X_train = tokeniser.texts_to_sequences(X_train)
+X_test = tokeniser.texts_to_sequences(X_test)
+
+vocab_size = len(tokeniser.word_index)+1
+
+max_review_length = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_review_length, padding = 'post')
+X_test = sequence.pad_sequences(X_test, maxlen=max_review_length, padding = 'post')
+
+n_features = X_train.shape[1]
+
+#Modelling a sample DNN
+model = Sequential()
+model.add(Dense(64, activation='relu',input_shape=(500,)))
+model.add(Dense(32, activation='relu'))
+model.add(Dense(16, activation='relu'))
+model.add(Dense(1,activation='sigmoid'))
+
+opt=Adam(learning_rate=0.01)
+model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['accuracy'])
+
+history=model.fit(X_train, y_train, epochs=50, batch_size=16)
+loss, acc = model.evaluate(X_test, y_test)
+
+model.save("dnn_model.h5")
+
+with open("dnn_tokeniser.pkl",'wb') as file:
+    pickle.dump(tokeniser, file) 

dnn_model.h5

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

dnn_tokeniser.pkl

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

lstm_model.h5

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

lstm_tokeniser.pkl

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

perceptron _.py

@@ -0,0 +1,41 @@
+from sklearn.model_selection import train_test_split
+import pandas as pd
+import tensorflow as tf
+from tensorflow.keras.preprocessing import sequence
+from Perceptron import  Perceptron
+import pickle
+
+
+from sklearn.metrics import accuracy_score
+from sklearn.metrics import classification_report
+
+dataset = pd.read_csv(r"IMDB Dataset.csv")
+
+dataset['sentiment'] = dataset['sentiment'].map( {'negative': 1, 'positive': 0} )
+X = dataset['review'].values
+y = dataset['sentiment'].values
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+tokeniser.fit_on_texts(X_train)
+X_train = tokeniser.texts_to_sequences(X_train)
+X_test = tokeniser.texts_to_sequences(X_test)
+
+max_review_length = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
+X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
+
+perceptron = Perceptron(epochs=10,activation_function='sigmoid')
+
+perceptron.fit(X_train, y_train)
+pred = perceptron.predict(X_test)
+
+print(f"Accuracy : {accuracy_score(pred, y_test)}")
+report = classification_report(pred, y_test, digits=2)
+
+print(report)
+
+with open("ppn_model.pkl",'wb') as file:
+    pickle.dump(perceptron, file) 
+with open("ppn_tokeniser.pkl",'wb') as file:
+    pickle.dump(tokeniser, file)     

ppn_model.pkl

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

ppn_tokeniser.pkl

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

simplelstm.py

@@ -0,0 +1,48 @@
+import tensorflow as tf
+import pandas as pd
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import LSTM
+from tensorflow.keras.layers import Embedding
+from tensorflow.keras.preprocessing import sequence
+from sklearn.model_selection import train_test_split
+from tensorflow.keras.models import save_model
+from tensorflow.keras.preprocessing.text import Tokenizer
+
+import pickle
+
+dataset = pd.read_csv(r"IMDB Dataset.csv")
+
+dataset['sentiment'] = dataset['sentiment'].map( {'negative': 1, 'positive': 0} )
+X = dataset['review'].values
+y = dataset['sentiment'].values
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+tokeniser.fit_on_texts(X_train)
+X_train = tokeniser.texts_to_sequences(X_train)
+X_test = tokeniser.texts_to_sequences(X_test)
+print(X_train[0:2])
+
+vocab_size = len(tokeniser.word_index)+1
+
+max_review_length = 500
+X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
+X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
+
+embedding_vector_length = 32
+model = Sequential()
+model.add(Embedding(vocab_size, embedding_vector_length, input_length=max_review_length))
+model.add(LSTM(100))
+model.add(Dense(1, activation='sigmoid'))
+model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+model.fit(X_train, y_train, epochs=3, batch_size=64)
+
+scores = model.evaluate(X_test, y_test, verbose=0)
+print("Accuracy: %.2f%%" % (scores[1]*100))
+
+model.save("lstm_model.h5")
+with open("lstm_tokeniser.pkl",'wb') as file:
+    pickle.dump(tokeniser, file)
+
+     

smsspam.py

@@ -0,0 +1,61 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+from keras.models import load_model
+from tensorflow.keras.models import save_model
+from tensorflow.keras.preprocessing.text import Tokenizer
+import pickle
+
+dataset = pd.read_csv(r"SMSSpamCollection.txt",sep='\t',names=['label','message'])
+
+dataset['label'] = dataset['label'].map( {'spam': 1, 'ham': 0} )
+X = dataset['message'].values
+y = dataset['label'].values
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+tokeniser.fit_on_texts(X_train)
+encoded_train = tokeniser.texts_to_sequences(X_train)
+encoded_test = tokeniser.texts_to_sequences(X_test)
+
+max_length = 10
+padded_train = tf.keras.preprocessing.sequence.pad_sequences(encoded_train, maxlen=max_length, padding='post')
+padded_test = tf.keras.preprocessing.sequence.pad_sequences(encoded_test, maxlen=max_length, padding='post')
+
+vocab_size = len(tokeniser.word_index)+1
+
+# define the model
+
+model=tf.keras.models.Sequential([
+   tf.keras.layers.Embedding(input_dim=vocab_size,output_dim= 24, input_length=max_length),
+   tf.keras.layers.SimpleRNN(24, return_sequences=False),
+   tf.keras.layers.Dense(64, activation='relu'),
+   tf.keras.layers.Dense(32, activation='relu'),
+   tf.keras.layers.Dense(1, activation='sigmoid')
+])
+
+# compile the model
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# summarize the model
+
+early_stop = tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode='min', patience=10)
+
+
+# fit the model
+model.fit(x=padded_train,
+         y=y_train,
+         epochs=50,
+         validation_data=(padded_test, y_test),
+         callbacks=[early_stop]
+         )
+
+preds = (model.predict(padded_test) > 0.5).astype("int32")
+
+model_filename = "spam_model.h5"
+model.save(model_filename)
+
+# Save the tokenizer using pickle
+tokeniser_filename = "spam_tokeniser.pkl"
+with open(tokeniser_filename, 'wb') as tokeniser_file:
+    pickle.dump(tokeniser, tokeniser_file)

spam_model.h5

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

spam_tokeniser.pkl

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

tasks.py

@@ -0,0 +1,153 @@
+import pandas as pd
+import streamlit as st
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+import pickle
+
+
+
+st.header('Neural Networks Demo')
+task = st.selectbox('Select Task', ["Select One",'Sentiment Classification', 'Tumor Detection'])
+
+
+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 "Tumor Detected"
+            else:
+                return "No Tumor" 
+            
+        cnn_model = tf.keras.models.load_model("tumor_detection_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)
+        
+
+        elif input_text2 == "RNN":
+                rnn_model=tf.keras.models.load_model("spam_model.h5")
+                with open("spam_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) > 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 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)  
+
+
+
+
+                
+
+
+
+

tumor_detection_model.h5

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

tumor_detection_model.pkl

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