File size: 7,458 Bytes
54f4801 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 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) |