Update model.py

model.py

@@ -11,74 +11,84 @@ from sklearn.metrics.pairwise import cosine_similarity
 from nltk.tokenize import sent_tokenize
 from transformers import pipeline
 import numpy as np
+import logging
 
 # === Pipelines ===
 summarizer = pipeline("summarization", model="csebuetnlp/mT5_multilingual_XLSum")
 qa_pipeline = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")
 emotion_pipeline = pipeline("text-classification", model="bhadresh-savani/distilbert-base-uncased-emotion", top_k=1)
 
-# === Summarization (Brief) ===
+# === Brief Summarization ===
 def summarize_review(text, max_len=60, min_len=10):
-    return summarizer(text, max_length=max_len, min_length=min_len, do_sample=False)[0]["summary_text"]
+    try:
+        return summarizer(text, max_length=max_len, min_length=min_len, do_sample=False)[0]["summary_text"]
+    except Exception as e:
+        logging.warning(f"Summarization fallback used: {e}")
+        return text
 
-# === Smart Summarization ===
+# === Smart Summarization with Clustering ===
 def smart_summarize(text, n_clusters=1):
-    sentences = sent_tokenize(text)
-    if len(sentences) <= 1:
+    try:
+        sentences = sent_tokenize(text)
+        if len(sentences) <= 1:
+            return text
+        tfidf = TfidfVectorizer(stop_words="english")
+        tfidf_matrix = tfidf.fit_transform(sentences)
+        if len(sentences) <= n_clusters:
+            return " ".join(sentences)
+        kmeans = KMeans(n_clusters=n_clusters, random_state=42).fit(tfidf_matrix)
+        summary_sentences = []
+        for i in range(n_clusters):
+            idx = np.where(kmeans.labels_ == i)[0]
+            if not len(idx):
+                continue
+            avg_vector = np.asarray(tfidf_matrix[idx].mean(axis=0))
+            sim = cosine_similarity(avg_vector, tfidf_matrix[idx].toarray())
+            most_representative = sentences[idx[np.argmax(sim)]]
+            summary_sentences.append(most_representative)
+        return " ".join(sorted(summary_sentences, key=sentences.index))
+    except Exception as e:
+        logging.error(f"Smart summarize error: {e}")
         return text
-    tfidf = TfidfVectorizer(stop_words="english")
-    tfidf_matrix = tfidf.fit_transform(sentences)
-    if len(sentences) <= n_clusters:
-        return " ".join(sentences)
-    kmeans = KMeans(n_clusters=n_clusters, random_state=42).fit(tfidf_matrix)
-    summary_sentences = []
-    for i in range(n_clusters):
-        idx = np.where(kmeans.labels_ == i)[0]
-        if not len(idx):
-            continue
-        avg_vector = np.asarray(tfidf_matrix[idx].mean(axis=0))
-        sim = cosine_similarity(avg_vector, tfidf_matrix[idx].toarray())
-        most_representative = sentences[idx[np.argmax(sim)]]
-        summary_sentences.append(most_representative)
-    return " ".join(sorted(summary_sentences, key=sentences.index))
 
 # === Emotion Detection ===
 def detect_emotion(text):
     try:
         result = emotion_pipeline(text)[0]
         return result["label"]
-    except Exception:
+    except Exception as e:
+        logging.warning(f"Emotion detection failed: {e}")
         return "neutral"
 
-# === Follow-up Q&A (single or multi) ===
+# === Follow-up Q&A (Flexible for list or str) ===
 def answer_followup(text, question, verbosity="brief"):
     try:
         if isinstance(question, list):
             answers = []
             for q in question:
                 response = qa_pipeline({"question": q, "context": text})
-                answer = response.get("answer", "")
+                ans = response.get("answer", "")
                 if verbosity.lower() == "detailed":
-                    answers.append(f"**{q}** → {answer}")
+                    answers.append(f"**{q}** → {ans}")
                 else:
-                    answers.append(answer)
+                    answers.append(ans)
             return answers
         else:
             response = qa_pipeline({"question": question, "context": text})
-            answer = response.get("answer", "")
-            if verbosity.lower() == "detailed":
-                return f"Based on the review, the answer is: **{answer}**"
-            return answer
-    except Exception:
+            ans = response.get("answer", "")
+            return f"**{question}** → {ans}" if verbosity.lower() == "detailed" else ans
+    except Exception as e:
+        logging.warning(f"Follow-up error: {e}")
         return "Sorry, I couldn't generate a follow-up answer."
 
-# === Fast follow-up (no formatting, for /followup) ===
+# === Fast follow-up (used for direct /followup route) ===
 def answer_only(text, question):
     try:
         if not question:
             return "No question provided."
         return qa_pipeline({"question": question, "context": text}).get("answer", "No answer found.")
-    except Exception:
+    except Exception as e:
+        logging.warning(f"Answer-only failed: {e}")
         return "Q&A failed."
 
 # === Optional Explanation Generator ===
@@ -86,7 +96,8 @@ def generate_explanation(text):
     try:
         explanation = summarizer(text, max_length=60, min_length=20, do_sample=False)[0]["summary_text"]
         return f"🧠 This review can be explained as: {explanation}"
-    except Exception:
+    except Exception as e:
+        logging.warning(f"Explanation failed: {e}")
         return "⚠️ Explanation could not be generated."
 
 # === Industry Detector ===