Update pages/model.py

pages/model.py

@@ -3,62 +3,58 @@ import pickle
 import re
 import numpy as np
 
-st.set_page_config(page_title="TagGPT - Stack Overflow Tag Predictor", layout="centered")
+st.set_page_config(page_title="🔖 TagGPT - Auto Tag Your Questions", layout="centered")
 
-# ---------- Text Preprocessing ----------
-def preprocess_input(text):
-    text = re.sub(r"<.*?>", " ", text)                  # Remove HTML tags
-    text = re.sub(r"[^a-zA-Z0-9\s]", " ", text)         # Remove special characters
-    text = re.sub(r"\s+", " ", text.lower()).strip()    # Lowercase and clean whitespace
-    return text
+def clean_text(raw_text):
+    raw_text = re.sub(r"<.*?>", " ", raw_text)  # Remove HTML tags
+    raw_text = re.sub(r"[^a-zA-Z0-9\s]", " ", raw_text)  # Remove special characters
+    raw_text = re.sub(r"\s+", " ", raw_text.lower()).strip()  # Lowercase & strip spaces
+    return raw_text
 
-# ---------- Load Model Assets ----------
 @st.cache_resource
-def load_model_assets():
+def load_assets():
     try:
-        with open("model.pkl", "rb") as f:
-            model = pickle.load(f)
-        with open("tfidf.pkl", "rb") as f:
-            vectorizer = pickle.load(f)
-        with open("mlb.pkl", "rb") as f:
-            encoder = pickle.load(f)
-        return model, vectorizer, encoder
-    except Exception as e:
-        st.error(f"❌ Error loading model assets: {e}")
+        with open("model.pkl", "rb") as m:
+            tag_model = pickle.load(m)
+        with open("tfidf.pkl", "rb") as v:
+            text_vectorizer = pickle.load(v)
+        with open("mlb.pkl", "rb") as e:
+            tag_encoder = pickle.load(e)
+        return tag_model, text_vectorizer, tag_encoder
+    except Exception as error:
+        st.error(f"❌ Failed to load model components: {error}")
         st.stop()
 
-model, vectorizer, encoder = load_model_assets()
+tag_model, text_vectorizer, tag_encoder = load_assets()
 
-# ---------- UI ----------
-st.title("🔖 TagGPT: Predict Stack Overflow Tags")
-st.markdown("Smartly auto-tag your programming questions using machine learning.")
+st.title("🎯 TagGPT - Smart Stack Overflow Tag Suggester")
+st.markdown("🚀 **Automatically generate relevant tags for your coding questions.**")
+st.markdown("Just enter your question title and description, and let AI do the tagging!")
 
-q_title = st.text_input("📝 Enter Question Title")
-q_body = st.text_area("📄 Describe Your Problem", height=200)
-threshold = st.slider("🎯 Prediction Threshold", 0.1, 0.9, 0.3, 0.05)
+question_title = st.text_input("🧠 Enter the **Question Title**")
+question_description = st.text_area("📝 Provide a **Detailed Description**", height=200)
+confidence_threshold = st.slider("📈 Select Tag Confidence Threshold", 0.1, 0.9, 0.3, 0.05)
 
-# ---------- Prediction ----------
-if st.button("🔍 Generate Tags"):
-    if not q_title.strip() or not q_body.strip():
-        st.warning("🚨 Please fill in both the title and description.")
+if st.button("🔍 Predict Tags"):
+    if not question_title.strip() or not question_description.strip():
+        st.warning("⚠️ Both title and description are required!")
     else:
-        user_query = preprocess_input(q_title + " " + q_body)
-        X_transformed = vectorizer.transform([user_query])
+        combined_input = clean_text(question_title + " " + question_description)
+        transformed_input = text_vectorizer.transform([combined_input])
 
         try:
-            # Handle both predict_proba and predict cases
-            if hasattr(model, "predict_proba"):
-                tag_probs = model.predict_proba(X_transformed)
-                tag_preds = (tag_probs >= threshold).astype(int)
+            if hasattr(tag_model, "predict_proba"):
+                probs = tag_model.predict_proba(transformed_input)
+                tag_preds = (probs >= confidence_threshold).astype(int)
             else:
-                tag_preds = model.predict(X_transformed)
+                tag_preds = tag_model.predict(transformed_input)
 
-            predicted = encoder.inverse_transform(tag_preds)
+            final_tags = tag_encoder.inverse_transform(tag_preds)
 
-            if predicted and predicted[0]:
-                st.success("✅ Predicted Tags:")
-                st.write(", ".join(predicted[0]))
+            if final_tags and final_tags[0]:
+                st.success("🏷️ **Predicted Tags:**")
+                st.markdown("🔸 " + ", ".join(final_tags[0]))
             else:
-                st.info("🤖 No tags predicted. Try refining your input or lowering the threshold.")
-        except Exception as e:
-            st.error(f"⚠️ Prediction failed: {e}")
+                st.info("🤖 No tags predicted. Try adjusting the threshold or refining your input.")
+        except Exception as error:
+            st.error(f"🚫 Prediction failed: {error}")