Upload 14 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+IMDB[[:space:]]Dataset.csv filter=lfs diff=lfs merge=lfs -text

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

IMDB Dataset.csv

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

Perceptron.py

@@ -0,0 +1,51 @@
+import numpy as np
+from tqdm import tqdm
+import joblib
+
+
+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
+    
+# Save the Perceptron model
+joblib.dump(Perceptron, 'perceptron_model.joblib')
+
+
+
+    
+    
+    
+ 

backprop_model.pkl

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

class.py

@@ -0,0 +1,142 @@
+import streamlit as st
+import numpy as np
+from PIL import Image
+from tensorflow.keras.models import load_model
+import joblib
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from tensorflow.keras.applications.inception_v3 import preprocess_input
+import cv2
+from Perceptron import  Perceptron
+from sklearn.linear_model import Perceptron
+import tensorflow as tf
+import joblib
+import pickle
+from numpy import argmax
+
+
+# Load the tokenizer using pickle
+with open(r'tokeniser.pkl', 'rb') as handle:
+    loaded_tokenizer = pickle.load(handle)
+
+# Load saved models
+image_model = load_model('tumor_detection_model.h5')
+dnn_model = load_model('imdb_model.h5')
+loaded_model = tf.keras.models.load_model('sms_spam_detection_dnnmodel.h5')  
+perceptron_model = joblib.load('perceptron_model.joblib')
+backprop_model = joblib.load('backprop_model.pkl')
+
+
+# Streamlit app     
+st.title("Classification")
+
+# Sidebar
+task = st.sidebar.selectbox("Select Task", ["Tumor Detection", "Sentiment Classification"])
+
+def preprocess_text(text):
+    tokenizer = Tokenizer()
+    tokenizer.fit_on_texts([text])
+    sequences = tokenizer.texts_to_sequences([text])
+    preprocessed_text = pad_sequences(sequences, maxlen=4)
+
+    return preprocessed_text
+
+
+
+def predict_dnn(preprocessed_text):
+    preprocessed_text = preprocessed_text.reshape((1, 4))  # Adjust the shape according to your model's input shape
+
+    prediction = dnn_model.predict(preprocessed_text)
+    st.write("DNN Prediction:", prediction)
+    
+    
+        
+def predict_rnn(input_text):
+    # Process input text similarly to training data
+    encoded_input = loaded_tokenizer.texts_to_sequences([input_text])
+    padded_input = tf.keras.preprocessing.sequence.pad_sequences(encoded_input, maxlen=10, padding='post')
+    prediction = loaded_model.predict(padded_input)
+    if prediction > 0.5:
+        return "spam"
+    else:
+        return "ham"
+
+
+def predict_custom_perceptron(preprocessed_text):
+    perceptron = CustomPerceptron(epochs=10)  # Using the custom Perceptron
+    prediction = perceptron.predict(preprocessed_text)
+    st.write("Custom Perceptron Prediction:", prediction)
+    
+def predict_sklearn_perceptron(preprocessed_text):
+    perceptron = SklearnPerceptron()  # Using the sklearn Perceptron
+    prediction = perceptron.predict(preprocessed_text)
+    st.write("Sklearn Perceptron Prediction:", prediction)
+    
+def predict_backpropagation(preprocessed_text):
+    prediction = backprop_model.predict(preprocessed_text)
+    st.write("Backpropagation Prediction:", prediction)
+
+# make a prediction for CNN
+def preprocess_image(image):
+    image = image.resize((299, 299))
+    image_array = np.array(image)
+    preprocessed_image = preprocess_input(image_array)
+
+    return preprocessed_image
+
+
+def make_prediction_cnn(image, image_model):
+    img = image.resize((128, 128))
+    img_array = np.array(img)
+    img_array = img_array.reshape((1, img_array.shape[0], img_array.shape[1], img_array.shape[2]))
+
+    preprocessed_image = preprocess_input(img_array)
+    prediction = image_model.predict(preprocessed_image)
+
+    if prediction > 0.5:
+        st.write("Tumor Detected")
+    else:
+        st.write("No Tumor")
+
+if task == "Sentiment Classification":
+    st.subheader("Choose Model")
+    model_choice = st.radio("Select Model", ["DNN", "RNN", "Perceptron", "Backpropagation"])
+
+    st.subheader("Text Input")
+    text_input = st.text_area("Enter Text")
+
+    if st.button("Predict"):
+        # Preprocess the text
+        preprocessed_text = preprocess_text(text_input)
+        if model_choice == "DNN":
+            predict_dnn(preprocessed_text)
+        elif model_choice == "RNN":
+            if text_input:
+                prediction_result = predict_rnn(text_input)
+                st.write(f"The message is classified as: {prediction_result}")
+            else:
+                st.write("Please enter some text for prediction")
+        elif model_choice == "Custom Perceptron":
+            predict_custom_perceptron(preprocessed_text)
+        elif model_choice == "Sklearn Perceptron":
+            predict_sklearn_perceptron(preprocessed_text)
+        elif model_choice == "Backpropagation":
+            predict_backpropagation(preprocessed_text)
+
+else:
+    st.subheader("Choose Model")
+    model_choice = st.radio("Select Model", ["CNN"])
+
+    st.subheader("Image Input")
+    image_input = st.file_uploader("Choose an image...", type="jpg")
+
+    if image_input is not None:
+        image = Image.open(image_input)
+        st.image(image, caption="Uploaded Image.", use_column_width=True)
+
+        # Preprocess the image
+        preprocessed_image = preprocess_image(image)
+
+        if st.button("Predict"):
+            if model_choice == "CNN":
+                make_prediction_cnn(image, image_model)

dnn_main.py

@@ -0,0 +1,32 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from tensorflow.keras.datasets import imdb
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+# Load the IMDb dataset
+(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)
+
+# Pad sequences to a fixed length
+max_length = 500
+train_data = pad_sequences(train_data, maxlen=max_length)
+test_data = pad_sequences(test_data, maxlen=max_length)
+
+# Define the model
+model = models.Sequential()
+model.add(layers.Embedding(input_dim=10000, output_dim=16, input_length=max_length))
+model.add(layers.Flatten())
+model.add(layers.Dense(32, activation='relu'))
+model.add(layers.Dense(1, activation='sigmoid'))
+
+# Compile the model
+model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
+
+# Display the model summary
+model.summary()
+
+# Train the model
+history = model.fit(train_data, train_labels, epochs=5, batch_size=32, validation_split=0.2)
+
+# Evaluate the model on the test set
+test_loss, test_accuracy = model.evaluate(test_data, test_labels)
+print(f'Test Accuracy: {test_accuracy * 100:.2f}%')

imdb_model.h5

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

imdb_perceptron_model.pkl

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

lstm_imdb_model.h5

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

perceptron_model.joblib

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

sms_spam_detection_dnnmodel.h5

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

smsspam.py

@@ -0,0 +1,94 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+import tensorflow as tf
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+
+print("---------------------- Downloading Dataset -------------------------\n")
+
+dataset = pd.read_csv('https://raw.githubusercontent.com/adityaiiitmk/Datasets/master/SMSSpamCollection',sep='\t',names=['label','message'])
+
+print("----------------------  -------------------------\n")
+print(dataset.head())
+print("----------------------  -------------------------")
+print(dataset.groupby('label').describe())
+print("----------------------  -------------------------")
+dataset['label'] = dataset['label'].map( {'spam': 1, 'ham': 0} )
+X = dataset['message'].values
+y = dataset['label'].values
+
+print("---------------------- Train Test Split -------------------------\n")
+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)        #learn vocabulary assigning unique int to each word
+encoded_train = tokeniser.texts_to_sequences(X_train)
+encoded_test = tokeniser.texts_to_sequences(X_test)
+print(encoded_train[0:2])
+print("----------------------  Padding  -------------------------\n")
+max_length = 10   #legth of sequence 
+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')
+print(padded_train[0:2])
+
+print("----------------------  -------------------------\n")
+
+vocab_size = len(tokeniser.word_index)+1
+
+# define the model
+
+print("---------------------- Modelling -------------------------\n")
+
+
+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),  #return last time output
+   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'])
+
+print("----------------------  -------------------------\n")
+
+# summarize the model
+print(model.summary())
+
+print("----------------------  -------------------------\n")
+
+early_stop = tf.keras.callbacks.EarlyStopping(monitor='accuracy', mode='min', patience=10)  #callback set of functions can applied different stages of training
+
+print("----------------------  Training -------------------------\n")
+
+# fit the model
+model.fit(x=padded_train,
+         y=y_train,
+         epochs=50,
+         validation_data=(padded_test, y_test),
+         callbacks=[early_stop]
+         )
+print("----------------------  -------------------------\n")
+
+
+def c_report(y_true, y_pred):
+   print("Classification Report")
+   print(classification_report(y_true, y_pred))
+   acc_sc = accuracy_score(y_true, y_pred)
+   print(f"Accuracy : {str(round(acc_sc,2)*100)}")
+   return acc_sc
+
+def plot_confusion_matrix(y_true, y_pred):
+   mtx = confusion_matrix(y_true, y_pred)
+   sns.heatmap(mtx, annot=True, fmt='d', linewidths=.5, cmap="Blues", cbar=False)
+   plt.ylabel('True label')
+   plt.xlabel('Predicted label')
+   plt.savefig(r"C:\Users\Dell\Documents\Sem !!!\Deep Learning\App\Results\test.jpg")
+
+
+preds = (model.predict(padded_test) > 0.5).astype("int32")
+c_report(y_test, preds)
+
+plot_confusion_matrix(y_test, preds)
+model.save("RNN/results/model/spam_model")

tokeniser.pkl

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

tumor_detection_model.h5

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