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
+
+
+    
+    
+    
+ 

app.py

@@ -0,0 +1,152 @@
+import pandas as pd
+import streamlit as st
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+import pickle
+
+
+st.header('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("rnn_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)  
+
+
+
+
+                
+
+
+
+

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"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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:e5b5110d992f43b2be8ae7213e998f5ed8364e0ea50160bf27a07f8eda3071b5
+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"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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,48 @@
+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
+import pickle
+
+dataset = pd.read_csv(r"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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:351a02fd6686d9bd4632e3639e90cfac8bac2e98ddd8c27347324c38b87bc26e
+size 457224

dnn_tokeniser.pkl

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

lstm_model.h5

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

lstm_tokeniser.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:919b41e8e2abcc668ea83f0c7454d0fe078a2c8a83bdbb23fb5c7c9daf703626
+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"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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:6b2f35d300e2e1e62ba318a5c87325ceaec298f9acd7d8e1d367e663ba049715
+size 2267

ppn_tokeniser.pkl

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

rnn_model.h5

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

simplelstm.py

@@ -0,0 +1,46 @@
+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
+
+import pickle
+
+dataset = pd.read_csv(r"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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,57 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+import pickle
+
+dataset = pd.read_csv(r"C:\Users\Ajitha V\OneDrive\Desktop\Neural_network\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.save("rnn_model.h5")
+
+with open("spam_tokeniser.pkl", 'wb') as model_file:
+    pickle.dump(tokeniser, model_file)
+
+

spam_tokeniser.pkl

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

tumor_detection_model.h5

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

tumor_detection_model.pkl

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