Update app.py

app.py

@@ -1,28 +1,27 @@
 # app.py
-# -*- coding: utf-8 -*-
-
 import os
 import re
-import warnings
 import joblib
+import torch
+import gradio as gr
 import numpy as np
 import pandas as pd
-import torch
+import warnings
+import nltk
+from nltk.corpus import stopwords
 from nltk.tokenize import word_tokenize
 from nltk.stem import WordNetLemmatizer
-from nltk.corpus import stopwords
-import nltk
-import gradio as gr
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
 
 warnings.filterwarnings("ignore")
 
-REPO_ID  = os.getenv("HF_REPO_ID", "Detecting-ai/text-detector-model-embedding")
-FILENAME = os.getenv("HF_FILENAME", "complete_trained_model_lite.joblib")
-REPO_TYPE = os.getenv("HF_REPO_TYPE", "model")
-HF_TOKEN = os.getenv("HF_TOKEN") or None
+# Hugging Face repo config
+REPO_ID = "Detecting-ai/text-detector-model-embedding"
+FILENAME = "complete_trained_model_lite.joblib"
+REPO_TYPE = "model"
 
+# NLTK ensure
 def ensure_nltk():
     try: nltk.data.find("tokenizers/punkt")
     except LookupError: nltk.download("punkt")
@@ -34,40 +33,35 @@ def ensure_nltk():
 ensure_nltk()
 
 def _to_stopword_set(sw):
-    if sw is None:
-        return set(stopwords.words("english"))
-    if isinstance(sw, (list, tuple)):
-        return set(sw)
-    if isinstance(sw, set):
-        return sw
-    try:
-        return set(sw)
-    except Exception:
-        return set(stopwords.words("english"))
-
-def _guess_model_by_dim(dim: int) -> str:
-    if dim == 768: return "sentence-transformers/all-mpnet-base-v2"
-    if dim == 384: return "sentence-transformers/all-MiniLM-L6-v2"
-    return "sentence-transformers/all-mpnet-base-v2"
+    if sw is None: return set(stopwords.words("english"))
+    if isinstance(sw, (list, tuple)): return set(sw)
+    if isinstance(sw, set): return sw
+    try: return set(sw)
+    except: return set(stopwords.words("english"))
+
+def _guess_model_by_dim(dim):
+    if dim == 768:
+        return "sentence-transformers/all-mpnet-base-v2"
+    if dim == 384:
+        return "sentence-transformers/all-MiniLM-L6-v2"
+    return "sentence-transformers/all-MiniLM-L6-v2"
 
 def load_embedding_model():
-    # Joblib siqilgan lite bundle ni yuklash (kichik va tez)
     path = hf_hub_download(
         repo_id=REPO_ID,
         filename=FILENAME,
-        repo_type=REPO_TYPE,
-        token=HF_TOKEN
+        repo_type=REPO_TYPE
     )
+    print(f"✅ Downloaded bundle from Hugging Face: {FILENAME}")
+
     data = joblib.load(path)
-    print(f"✅ Loaded lite bundle: {REPO_ID}/{FILENAME}")
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    env_name = os.getenv("EMBEDDING_MODEL_NAME", "").strip()
     stored_name = (data.get("embedding_model_name") or data.get("embedding_model_path") or "").strip()
-    expected_dim = int(data.get("embedding_dim", 0)) if data.get("embedding_dim") is not None else 0
-    emb_name = env_name or stored_name or _guess_model_by_dim(expected_dim)
+    expected_dim = int(data.get("embedding_dim", 0)) if data.get("embedding_dim") else 0
+    emb_name = stored_name or _guess_model_by_dim(expected_dim)
 
-    print(f"🔧 Loading ST: {emb_name} on {device}")
+    print(f"🔧 Loading embedding model: {emb_name} on {device}")
     embedding_model = SentenceTransformer(emb_name, device=device)
     actual_dim = embedding_model.get_sentence_embedding_dimension()
 
@@ -75,14 +69,10 @@ def load_embedding_model():
     data["resolved_embedding_model_name"] = emb_name
     data["resolved_embedding_dim"] = actual_dim
     data["device"] = device
-
-    if "lemmatizer" not in data or data["lemmatizer"] is None:
-        data["lemmatizer"] = WordNetLemmatizer()
+    data["lemmatizer"] = data.get("lemmatizer") or WordNetLemmatizer()
     data["stop_words"] = _to_stopword_set(data.get("stop_words"))
-    if "max_tokens" not in data:
-        data["max_tokens"] = 600
+    data["max_tokens"] = data.get("max_tokens", 600)
 
-    print(f"ℹ️ Expect dim={expected_dim}, using {emb_name} (dim={actual_dim})")
     return data
 
 def preprocess_text(text, lemmatizer, stop_words, max_tokens=600):
@@ -94,27 +84,24 @@ def preprocess_text(text, lemmatizer, stop_words, max_tokens=600):
         for tok in word_tokenize(text)
         if tok not in stop_words and len(tok) > 2
     ]
-    if len(tokens) > max_tokens:
-        tokens = tokens[:max_tokens]
-    return " ".join(tokens)
+    return " ".join(tokens[:max_tokens])
 
 def predict_text(text, model_data):
     proc = preprocess_text(text, model_data["lemmatizer"], model_data["stop_words"], model_data["max_tokens"])
     if not proc:
         return "UNKNOWN", 0.0, {"error": "Empty text after preprocessing"}
+
     with torch.no_grad():
         emb = model_data["embedding_model"].encode([proc], convert_to_numpy=True, normalize_embeddings=False)
-    if emb.ndim == 1:
-        emb = emb.reshape(1, -1)
+    if emb.ndim == 1: emb = emb.reshape(1, -1)
+
     clf = model_data["model"]
     try:
         pred = clf.predict(emb)[0]
-        if hasattr(clf, "predict_proba"):
-            conf = float(np.max(clf.predict_proba(emb)[0]))
-        else:
-            conf = 0.5
-    except ValueError as e:
-        return "ERROR_DIM_MISMATCH", 0.0, {"error": str(e)}
+        conf = float(np.max(clf.predict_proba(emb)[0])) if hasattr(clf, "predict_proba") else 0.5
+    except Exception as e:
+        return "ERROR", 0.0, {"error": str(e)}
+
     return str(pred), conf, {"tokens": len(proc.split())}
 
 def create_app(model_data):
@@ -130,8 +117,8 @@ def create_app(model_data):
                 headline = f"🤖 **AI Generated** (Conf: {conf:.1%})"
             elif label.upper() == "HUMAN":
                 headline = f"👤 **Human Written** (Conf: {conf:.1%})"
-            elif label == "ERROR_DIM_MISMATCH":
-                headline = f"❌ Dim mismatch (Conf: {conf:.1%})"
+            elif label.upper() == "ERROR":
+                headline = f"❌ Error: {meta.get('error', 'Unknown')}"
             else:
                 headline = f"❓ {label} (Conf: {conf:.1%})"
             det = f"- Tokens: {meta.get('tokens','?')}\n- Embedding: {model_data['resolved_embedding_model_name']} (dim={model_data['resolved_embedding_dim']})"
@@ -139,6 +126,7 @@ def create_app(model_data):
 
         inp.submit(_predict_ui, inp, [out, details])
         gr.Button("🔍 Predict").click(_predict_ui, inp, [out, details])
+
     return demo
 
 _model_data = load_embedding_model()