Upload 9 files

fasttext_domain.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6fa43d70ea51575d93ce96c5ec1bba03100c72dfdf42fb6f2b08289aeeb41b2
+size 10264425

fasttext_domain.model.wv.vectors_ngrams.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5bdd748f437a21795f12887e0ad1e8252c6b344e1d17951409be23bdb9d2be7
+size 800000128

hierarchy_meta.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8d1a32d2179b1c66893c590965381670e1fd3dd3c20e938104dcda8373e620c
+size 201257

le_queue.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33ff94621a99ad9d7efbf82d17c5ade73e2de7c34e85475eb34fcaba95c31e51
+size 451

le_type.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fabb50e2a8d002d772570d4344ef077ab5cbf69aef6cd6899bf89023c543c7a
+size 282

mlb.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9809424782574009a156d26fee95e1198229f7238afd3eeaf88d1bdafa36752e
+size 20183

multi_task_bilstm_attention.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18969fb045ae33fb7570ea20f3cb02ae7fb45bd03cce42724bb2c086ca9e5be9
+size 14278880

shubham (2).py

@@ -0,0 +1,185 @@
+import os
+import base64
+import traceback
+import streamlit as st
+import numpy as np
+import pickle
+import tensorflow as tf
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from tensorflow.keras import layers
+from tensorflow.keras.models import load_model
+from gensim.models import FastText
+import nltk
+import re
+from nltk.corpus import stopwords
+from nltk.tokenize import TreebankWordTokenizer
+
+# ------------------- Config -------------------
+MODEL_PATH = "multi_task_bilstm_attention.h5"
+FASTTEXT_PATH = "fasttext_domain.model"
+TOKENIZER_PKL = "tokenizer.pkl"
+LE_TYPE_PKL = "le_type.pkl"
+LE_QUEUE_PKL = "le_queue.pkl"
+MLB_PKL = "mlb.pkl"
+META_PKL = "hierarchy_meta.pkl"
+MAX_LEN = 120
+
+# ------------------- NLTK -------------------
+try: _ = stopwords.words("english")
+except: nltk.download("stopwords")
+try: _ = nltk.word_tokenize("test")
+except: nltk.download("punkt")
+
+stop_words = set(stopwords.words("english"))
+tokenizer_nltk = TreebankWordTokenizer()
+
+def clean_text(text):
+    text = str(text)
+    text = re.sub(r"<.*?>", " ", text)
+    text = re.sub(r"[^A-Za-z0-9 ]", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text.lower()
+
+def preprocess_text(text):
+    toks = tokenizer_nltk.tokenize(clean_text(text))
+    toks = [t for t in toks if t not in stop_words and len(t) > 1]
+    return " ".join(toks)
+
+# ------------------- Custom Attention -------------------
+class AttentionLayer(layers.Layer):
+    def build(self, input_shape):
+        self.W = self.add_weight(shape=(input_shape[-1], input_shape[-1]), initializer="glorot_uniform", trainable=True)
+        self.v = self.add_weight(shape=(input_shape[-1],), initializer="glorot_uniform", trainable=True)
+        super().build(input_shape)
+    def call(self, x):
+        u = tf.tanh(tf.tensordot(x, self.W, axes=1))
+        a = tf.nn.softmax(tf.tensordot(u, self.v, axes=1), axis=1)
+        return tf.reduce_sum(x * tf.expand_dims(a, -1), axis=1)
+
+# ------------------- Safe Loaders -------------------
+def safe_pickle(p): 
+    return pickle.load(open(p, "rb")) if os.path.exists(p) else None
+
+def safe_model(p):
+    if not os.path.exists(p): return None
+    with tf.keras.utils.custom_object_scope({"AttentionLayer": AttentionLayer}):
+        return load_model(p, compile=False)
+
+def safe_fasttext(p):
+    return FastText.load(p) if os.path.exists(p) else None
+
+tokenizer = safe_pickle(TOKENIZER_PKL)
+le_type = safe_pickle(LE_TYPE_PKL)
+le_queue = safe_pickle(LE_QUEUE_PKL)
+mlb = safe_pickle(MLB_PKL)
+meta = safe_pickle(META_PKL)
+
+model = safe_model(MODEL_PATH)
+fasttext = safe_fasttext(FASTTEXT_PATH)
+
+if meta is None:
+    type_queue_mask = None; type_queue_tag_mask = None; best_thr = 0.5
+else:
+    type_queue_mask = meta.get("type_queue_mask", None)
+    type_queue_tag_mask = meta.get("type_queue_tag_mask", None)
+    best_thr = float(meta.get("best_thr", 0.5))
+
+# Fallbacks
+class DummyLE: 
+    def inverse_transform(self, X): return [str(int(x)) for x in X]
+class DummyMLB:
+    def inverse_transform(self, X): return [tuple()]
+
+if tokenizer is None:
+    from tensorflow.keras.preprocessing.text import Tokenizer
+    tokenizer = Tokenizer(num_words=20000, oov_token="<OOV>")
+if le_type is None: le_type = DummyLE()
+if le_queue is None: le_queue = DummyLE()
+if mlb is None: mlb = DummyMLB()
+
+# ------------------- Inference -------------------
+def infer(text):
+    if model is None: raise RuntimeError("Model not loaded")
+    seq = tokenizer.texts_to_sequences([preprocess_text(text)])
+    seq = pad_sequences(seq, maxlen=MAX_LEN)
+
+    extra = np.zeros((1,2), dtype=np.int32)
+    preds = model.predict([seq, extra], verbose=0) if len(model.inputs) > 1 else model.predict(seq, verbose=0)
+    if isinstance(preds, (list,tuple)):
+        p_type, p_queue, p_tags = preds[0][0], preds[1][0], preds[2][0]
+    else:
+        arr = preds[0]; n=len(arr); t=max(1,n//3)
+        p_type, p_queue, p_tags = arr[:t], arr[t:2*t], arr[2*t:]
+
+    t_idx = np.argmax(p_type)
+    type_lbl = le_type.inverse_transform([t_idx])[0]
+
+    q_idx = np.argmax(p_queue)
+    queue_lbl = le_queue.inverse_transform([q_idx])[0]
+
+    if type_queue_tag_mask is not None:
+        mask = type_queue_tag_mask[t_idx, q_idx]
+        mod = p_tags * mask if mask.sum() != 0 else p_tags
+    else:
+        mod = p_tags
+
+    pred_bin = (mod >= best_thr).astype(int).reshape(1,-1)
+    try: tags = mlb.inverse_transform(pred_bin)[0]
+    except: tags = ()
+
+    return type_lbl, queue_lbl, list(tags)
+
+# ------------------- UI -------------------
+st.set_page_config(page_title="Multilingual Ticket Classification")
+
+# Background + UI styling + BLACK fonts
+if os.path.exists("bg.jpg"):
+    b64 = base64.b64encode(open("bg.jpg","rb").read()).decode()
+    st.markdown(f"""
+    <style>
+    .stApp {{
+        background-image: url("data:image/jpg;base64,{b64}");
+        background-size: cover;
+    }}
+    * {{ color: black !important; }}
+    .card {{
+        background: rgba(255,255,255,0.92);
+        border-radius: 12px;
+        padding: 22px;
+    }}
+    </style>
+    """, unsafe_allow_html=True)
+
+st.markdown("<h1 style='text-align:center;'>Multilingual Ticket Classification</h1>", unsafe_allow_html=True)
+st.markdown("<div class='card'>", unsafe_allow_html=True)
+
+message = st.text_area("Enter ticket message:", height=200)
+
+if st.button("Predict"):
+    if not message.strip():
+        st.warning("Please enter a ticket message.")
+    else:
+        try:
+            t, q, tg = infer(message)
+            st.subheader("TYPE")
+            st.success(t)
+
+            st.subheader("QUEUE")
+            st.success(q)
+
+            st.subheader("TAGS")
+            st.success(", ".join(tg) if tg else "No tags predicted.")
+        except Exception:
+            st.error("Prediction failed — model or artifacts missing.")
+            st.text(traceback.format_exc())
+
+st.markdown("</div>", unsafe_allow_html=True)
+
+# Invisible debug — exists internally but 100% hidden
+st.markdown("""
+<style>
+div[data-testid="stExpander"] {visibility: hidden; height: 0px;}
+</style>s
+""", unsafe_allow_html=True)
+with st.expander("debug_info_hidden"):
+    st.write("hidden diagnostics active")

tokenizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2692631d5f5722f104a8042a51a0048d1570c5c2075f57f2ed22f2f54dc2694a
+size 912026