Update app.py

app.py

@@ -1,78 +1,100 @@
 import streamlit as st
-import numpy as np
 import pandas as pd
 import tensorflow as tf
+from tensorflow.keras.preprocessing.text import Tokenizer
 from tensorflow.keras.preprocessing.sequence import pad_sequences
+from sklearn.model_selection import train_test_split
+import numpy as np
 from lime.lime_text import LimeTextExplainer
 import matplotlib.pyplot as plt
 
-# Load model and tokenizer
-@st.cache(allow_output_mutation=True)
-def load_model_and_tokenizer(model_path, tokenizer_path):
-    model = tf.keras.models.load_model(model_path)
-    tokenizer = pd.read_pickle(tokenizer_path)
-    return model, tokenizer
+# Streamlit Title
+st.title("Prompt Injection Detection and Prevention")
+st.write("Detect malicious prompts and understand predictions using deep learning and LIME.")
 
-# Preprocess input for prediction
-def preprocess_prompt(prompt, tokenizer, max_length):
-    sequence = tokenizer.texts_to_sequences([prompt])
-    padded_sequence = pad_sequences(sequence, maxlen=max_length)
-    return padded_sequence
+# Cache Data Loading
+@st.cache_data
+def load_data(filepath):
+    return pd.read_csv(filepath)
 
-# Make predictions
-def detect_prompt(prompt, model, tokenizer, max_length):
-    processed_prompt = preprocess_prompt(prompt, tokenizer, max_length)
-    prediction = model.predict(processed_prompt)[0][0]
-    class_label = "Malicious" if prediction >= 0.5 else "Valid"
-    confidence_score = prediction * 100 if prediction >= 0.5 else (1 - prediction) * 100
-    return class_label, confidence_score
+# Cache Model Loading
+@st.cache_resource
+def load_model(filepath):
+    return tf.keras.models.load_model(filepath)
 
-# Explain predictions using LIME
-def lime_explain(prompt, model, tokenizer, max_length):
-    def predict_fn(prompts):
-        sequences = tokenizer.texts_to_sequences(prompts)
-        padded_sequences = pad_sequences(sequences, maxlen=max_length)
-        predictions = model.predict(padded_sequences)
-        return np.hstack([1 - predictions, predictions])  # [P(valid), P(malicious)]
+# File Upload Section
+uploaded_file = st.file_uploader("Upload your dataset (.csv)", type=["csv"])
+if uploaded_file is not None:
+    data = load_data(uploaded_file)
+    st.write("Dataset Preview:")
+    st.write(data.head())
+    
+    # Data Preprocessing
+    data['label'] = data['label'].replace({'valid': 0, 'malicious': 1})
+    X = data['input'].values
+    y = data['label'].values
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
-    explainer = LimeTextExplainer(class_names=["Valid", "Malicious"])
-    explanation = explainer.explain_instance(prompt, predict_fn, num_features=10)
-    return explanation
+    # Tokenization and Padding
+    tokenizer = Tokenizer(num_words=5000)
+    tokenizer.fit_on_texts(X_train)
+    max_length = 100
+    X_train_pad = pad_sequences(tokenizer.texts_to_sequences(X_train), maxlen=max_length)
+    X_test_pad = pad_sequences(tokenizer.texts_to_sequences(X_test), maxlen=max_length)
 
-# Set up Streamlit app
-st.title("Prompt Injection Detection and Prevention")
-st.write("Detect malicious prompts and understand predictions using deep learning and LIME.")
+    # Load Deep Learning Model
+    model_path = st.text_input("Enter the path to your trained model (.h5):")
+    if model_path:
+        try:
+            model = load_model(model_path)
+            st.success("Model Loaded Successfully!")
+
+            # Test Prediction Functionality
+            def preprocess_prompt(prompt, tokenizer, max_length):
+                sequence = tokenizer.texts_to_sequences([prompt])
+                return pad_sequences(sequence, maxlen=max_length)
+
+            def detect_prompt(prompt):
+                processed_prompt = preprocess_prompt(prompt, tokenizer, max_length)
+                prediction = model.predict(processed_prompt)[0][0]
+                class_label = 'Malicious' if prediction >= 0.5 else 'Valid'
+                confidence_score = prediction * 100 if prediction >= 0.5 else (1 - prediction) * 100
+                return class_label, confidence_score
+
+            # User Input for Prompt Detection
+            st.subheader("Test a Prompt")
+            user_prompt = st.text_input("Enter a prompt to test:")
+            if user_prompt:
+                class_label, confidence_score = detect_prompt(user_prompt)
+                st.write(f"Predicted Class: **{class_label}**")
+                st.write(f"Confidence Score: **{confidence_score:.2f}%**")
+
+            # LIME Explanation
+            explainer = LimeTextExplainer(class_names=["Valid", "Malicious"])
 
-# Load model and tokenizer
-model_path = "path/to/your/saved_model"
-tokenizer_path = "path/to/your/tokenizer.pkl"
-max_length = 100  # Update based on your model
-model, tokenizer = load_model_and_tokenizer(model_path, tokenizer_path)
+            def lime_explain(prompt):
+                def predict_fn(prompts):
+                    sequences = tokenizer.texts_to_sequences(prompts)
+                    padded_sequences = pad_sequences(sequences, maxlen=max_length)
+                    predictions = model.predict(padded_sequences)
+                    return np.hstack([1 - predictions, predictions])
 
-# Input prompt
-user_input = st.text_area("Enter your prompt:", height=150)
+                explanation = explainer.explain_instance(
+                    prompt,
+                    predict_fn,
+                    num_features=10
+                )
+                return explanation
 
-if st.button("Detect"):
-    if user_input.strip() == "":
-        st.error("Please enter a prompt.")
-    else:
-        # Prediction
-        class_label, confidence_score = detect_prompt(user_input, model, tokenizer, max_length)
-        st.subheader("Detection Result:")
-        st.write(f"**Class:** {class_label}")
-        st.write(f"**Confidence Score:** {confidence_score:.2f}%")
+            st.subheader("LIME Explanation")
+            if user_prompt:
+                explanation = lime_explain(user_prompt)
+                explanation_as_html = explanation.as_html()
+                st.components.v1.html(explanation_as_html, height=500)
 
-        # Generate LIME explanation
-        st.subheader("Explanation:")
-        explanation = lime_explain(user_input, model, tokenizer, max_length)
-        fig = explanation.as_pyplot_figure()
-        st.pyplot(fig)
+        except Exception as e:
+            st.error(f"Error Loading Model: {e}")
 
-# Sidebar information
-st.sidebar.title("About")
-st.sidebar.info(
-    """
-    This app uses a deep learning model to classify prompts as "Malicious" or "Valid."
-    LIME explanations are provided to interpret the predictions.
-    """
-)
+# Footer
+st.write("---")
+st.write("Developed for detecting and preventing prompt injection attacks using Streamlit.")