Upload 15 files

App.py

@@ -0,0 +1,201 @@
+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
+from tensorflow.keras.datasets import imdb
+
+import cv2
+from BackPropogation import BackPropogation
+from Perceptron import  Perceptron
+from sklearn.linear_model import Perceptron
+import tensorflow as tf
+import joblib
+import pickle
+from numpy import argmax
+
+
+# Load saved models
+image_model = load_model('tumor_detection_model.h5')
+dnn_model = load_model('sms_spam_detection_dnnmodel.h5')
+rnn_model = load_model('spam_detection_rnn_model.h5')
+
+# Loading the model using pickle
+with open(r'D:/one/OneDrive/Desktop/Streamlit/Model_backprop.pkl', 'rb') as file:
+    backprop_model = pickle.load(file)
+
+with open(r'D:/one/OneDrive/Desktop/Streamlit/Percep_model.pkl', 'rb') as file:
+    perceptron_model = pickle.load(file)
+
+with open(r'D:/one/OneDrive/Desktop/Streamlit/tokeniser.pkl', 'rb') as file:
+    loaded_tokeniser = pickle.load(file)
+
+lstm_model_path='Lstm_model.h5'
+
+# Streamlit app     
+st.title("Classification")
+
+# Sidebar
+task = st.sidebar.selectbox("Select Task", ["Tumor Detection ", "Sentiment Classification"])
+tokeniser = tf.keras.preprocessing.text.Tokenizer()
+max_length=10
+
+def predictdnn_spam(text):
+        sequence = loaded_tokeniser.texts_to_sequences([text])
+        padded_sequence = pad_sequences(sequence, maxlen=10)
+        prediction = dnn_model.predict(padded_sequence)[0][0]
+        if prediction >= 0.5:
+            return "not spam"
+        else:
+            return "spam"
+def preprocess_imdbtext(text, maxlen=200, num_words=10000):
+    # Tokenizing the text
+    tokenizer = Tokenizer(num_words=num_words)
+    tokenizer.fit_on_texts(text)
+    
+    # Converting text to sequences
+    sequences = tokenizer.texts_to_sequences(text)
+    
+    # Padding sequences to a fixed length
+    padded_sequences = pad_sequences(sequences, maxlen=maxlen)
+    
+    return padded_sequences, tokenizer
+
+def predict_sentiment_backprop(text, model):
+    preprocessed_text = preprocess_imdbtext(text, 200)  
+    prediction = backprop_model.predict(preprocessed_text)
+    return prediction
+
+def preprocess_imdb_lstm(user_input, tokenizer, max_review_length=500):
+        # Tokenize and pad the user input
+        user_input_sequence = tokenizer.texts_to_sequences([user_input])
+        user_input_padded = pad_sequences(user_input_sequence, maxlen=max_review_length)
+        return user_input_padded
+
+def predict_sentiment_lstm(model, user_input, tokenizer):
+        preprocessed_input = preprocess_imdb_lstm(user_input, tokenizer)
+        prediction = model.predict(preprocessed_input)
+        return prediction
+
+def predict_sentiment_precep(user_input, num_words=1000, max_len=200):
+        word_index = imdb.get_word_index()
+        input_sequence = [word_index[word] if word in word_index and word_index[word] < num_words else 0 for word in user_input.split()]
+        padded_sequence = pad_sequences([input_sequence], maxlen=max_len)
+        return padded_sequence 
+    
+    
+
+def preprocess_message_dnn(message, tokeniser, max_length):
+    # Tokenize and pad the input message
+    encoded_message = tokeniser.texts_to_sequences([message])
+    padded_message = tf.keras.preprocessing.sequence.pad_sequences(encoded_message, maxlen=max_length, padding='post')
+    return padded_message
+
+def predict_rnnspam(message, tokeniser, max_length):
+    # Preprocess the message
+    processed_message = preprocess_message_dnn(message, tokeniser, max_length)
+    
+    # Predict spam or ham
+    prediction = rnn_model.predict(processed_message)
+    if prediction >= 0.5:
+        return "Spam"
+    else:
+        return "Ham"
+
+
+# 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","LSTM"])
+
+    st.subheader("Text Input")
+    
+
+    if model_choice=='DNN':
+        text_input = st.text_area("Enter Text")
+        if st.button("Predict"):
+            if text_input:
+                        prediction_result = predictdnn_spam(text_input)
+                        st.write(f"The review's class is: {prediction_result}")
+            else:
+                        st.write("Enter a movie review")
+
+    elif model_choice == "RNN":
+            text_input = st.text_area("Enter Text")
+            if text_input:
+                prediction_result = predict_rnnspam(text_input,loaded_tokeniser,max_length=10)
+            if st.button("Predict"):   
+                st.write(f"The message is classified as: {prediction_result}")
+            else:
+                st.write("Please enter some text for prediction")
+    elif model_choice == "Perceptron":
+                text_input = st.text_area("Enter Text" )
+                if st.button('Predict'):
+                    processed_input = predict_sentiment_precep(text_input)
+                    prediction = perceptron_model.predict(processed_input)[0]
+                    sentiment = "Positive" if prediction == 1 else "Negative"
+                    st.write(f"Predicted Sentiment: {sentiment}")
+    elif model_choice == "LSTM":
+            
+            lstm_model = tf.keras.models.load_model(lstm_model_path)
+            text_input = st.text_area("Enter text for sentiment analysis:", "")
+            if st.button("Predict"):
+                tokenizer = Tokenizer(num_words=5000)
+                prediction = predict_sentiment_lstm(lstm_model, text_input, tokenizer)
+
+                if prediction[0][0]<0.5 :
+                    result="Negative"
+                    st.write(f"The message is classified as: {result}")
+                else:
+                    result="Positive"
+                    st.write(f"The message is classified as: {result}")
+
+    elif model_choice == "Backpropagation":
+                text_input = st.text_area("Enter Text" )
+                if st.button('Predict'):
+                    processed_input = predict_sentiment_precep(text_input)
+                    prediction = backprop_model.predict(processed_input)[0]
+                    sentiment = "Positive" if prediction == 1 else "Negative"
+                    st.write(f"Predicted Sentiment: {sentiment}")
+
+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)
+
+

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

Lstm_model.h5

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

Model_backprop.pkl

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

Percep_model.pkl

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

Perceptron.py

@@ -0,0 +1,40 @@
+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

chck.py

@@ -0,0 +1,80 @@
+import streamlit as st
+import numpy as np
+from PIL import Image
+from tensorflow.keras.models import load_model
+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 tensorflow as tf
+import joblib
+
+# Load saved models
+image_model = load_model('tumor_detection_model.h5')
+dnn_model = load_model('sms_spam_detection_dnnmodel.h5')
+rnn_model = load_model('spam_detection_rnn_model.h5')
+perceptron_model = joblib.load('imdb_perceptron_model.pkl')
+backprop_model = joblib.load('backprop_model.pkl')
+LSTM_model = load_model('imdb_LSTM.h5')
+
+# Streamlit app
+st.title("Classification")
+
+# Sidebar
+task = st.sidebar.selectbox("Select Task", ["Tumor Detection", "Sentiment Classification"])
+
+def preprocess_message_dnn(message, tokeniser, max_length):
+    encoded_message = tokeniser.texts_to_sequences([message])
+    padded_message = pad_sequences(encoded_message, maxlen=max_length, padding='post')
+    return padded_message
+
+def predict_dnnspam(message, tokeniser, max_length):
+    processed_message = preprocess_message_dnn(message, tokeniser, max_length)
+    prediction = dnn_model.predict(processed_message)
+    return "Spam" if prediction >= 0.5 else "Ham"
+
+# Other prediction functions for sentiment analysis can follow a similar pattern
+
+# Function for CNN prediction
+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, 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 = model.predict(preprocessed_image)
+    return "Tumor Detected" if prediction > 0.5 else "No Tumor"
+
+if task == "Sentiment Classification":
+    st.subheader("Choose Model")
+    model_choice = st.radio("Select Model", ["DNN", "RNN", "Perceptron", "Backpropagation", "LSTM"])
+
+    st.subheader("Text Input")
+    text_input = st.text_area("Enter Text")
+
+    if st.button("Predict"):
+        if model_choice == "DNN":
+            # You need to define tokeniser and max_length for DNN model
+            prediction_result = predict_dnnspam(text_input, tokeniser, max_length)
+            st.write(f"The message is classified as: {prediction_result}")
+        # Other model choices should call respective prediction functions similarly
+
+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)
+
+        if st.button("Predict"):
+            if model_choice == "CNN":
+                prediction_result = make_prediction_cnn(image, image_model)
+                st.write(prediction_result)

imdb_LSTM.h5

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

lstm.h5

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

requirements.txt

@@ -0,0 +1,7 @@
+opencv-python
+streamlit
+Pillow
+tensorflow
+numpy
+tqdm
+scikit-learn

sms_spam_detection_dnnmodel.h5

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

spam_detection_rnn_model.h5

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

tokeniser.pkl

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

tumor_detection_model.h5

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