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('Model_backprop.pkl', 'rb') as file:
backprop_model = pickle.load(file)
with open('Percep_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)