Update app.py

app.py

@@ -6,8 +6,6 @@ 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
@@ -18,93 +16,66 @@ 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('sms_spam_detection_dnnmodel.h5')
-rnn_model = load_model('spam_detection_rnn_model.h5')
-
-# Loading the model using pickle
-with open('Model_backprop.pkl', 'rb') as file:
-    backprop_model = pickle.load(file)
-
-with open('Percep_model.pkl', 'rb') as file:
-    perceptron_model = pickle.load(file)
+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')
 
-with open('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
+task = st.sidebar.selectbox("Select Task", ["Tumor Detection", "Sentiment Classification"])
 
-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_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 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)
+
+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)
+    
     
-    # Predict spam or ham
-    prediction = rnn_model.predict(processed_message)
-    if prediction >= 0.5:
-        return "Spam"
+        
+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"
+        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):
@@ -114,6 +85,7 @@ def preprocess_image(image):
 
     return preprocessed_image
 
+
 def make_prediction_cnn(image, image_model):
     img = image.resize((128, 128))
     img_array = np.array(img)
@@ -126,59 +98,31 @@ def make_prediction_cnn(image, image_model):
         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"])
+    model_choice = st.radio("Select Model", ["DNN", "RNN", "Perceptron", "Backpropagation"])
 
     st.subheader("Text Input")
-    
-
-    if model_choice=='DNN':
-        text_input = st.text_area("Enter Text")
-        if st.button("Predict"):
+    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 = 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"):   
+                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 == "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}")
+        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")
@@ -196,6 +140,4 @@ else:
 
         if st.button("Predict"):
             if model_choice == "CNN":
-                make_prediction_cnn(image, image_model)
-
-
+                make_prediction_cnn(image, image_model)