Upload app.py

app.py

@@ -0,0 +1,198 @@
+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 the 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('backpropagation-model.pkl', 'rb') as file:
+    backprop_model = pickle.load(file)
+
+with open('Perceptron_model.pkl', 'rb') as file:
+    perceptron_model = pickle.load(file)
+
+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
+
+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)