Update app.py

app.py

@@ -36,7 +36,8 @@ def index():
             "POST /api/coffee/forecast",
             "POST /api/coffee/menu-analysis",
             "POST /api/hr/classify",
-            "POST /api/lottery/analyze"
+            "POST /api/lottery/analyze",
+            "POST /api/sentiment/analyze"
         ]
     })
 
@@ -600,6 +601,285 @@ def hr_classify():
         return jsonify({"error": str(e)}), 500
 
 
+# ─────────────────────────────────────
+# POST /api/sentiment/analyze
+# วิเคราะห์ความรู้สึกลูกค้าจาก reviews
+# models: logistic | random_forest | xgboost | all
+# ─────────────────────────────────────
+@app.route("/api/sentiment/analyze", methods=["POST", "OPTIONS"])
+def sentiment_analyze():
+    if request.method == "OPTIONS":
+        return jsonify({}), 200
+    try:
+        import time
+        t0 = time.time()
+        from sklearn.feature_extraction.text import TfidfVectorizer
+        from sklearn.linear_model import LogisticRegression
+        from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+        from sklearn.model_selection import train_test_split
+        from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
+        from sklearn.pipeline import Pipeline
+        from collections import Counter
+
+        body = request.get_json()
+        data = body.get("data", [])
+        model_type = body.get("model", "logistic").lower()
+
+        if len(data) < 5:
+            return jsonify({"error": "ต้องการข้อมูลอย่างน้อย 5 reviews"}), 400
+
+        df = pd.DataFrame(data)
+        if "review_text" not in df.columns:
+            return jsonify({"error": "Missing column: review_text"}), 400
+
+        df["review_text"] = df["review_text"].fillna("").astype(str)
+        has_label = "sentiment" in df.columns and df["sentiment"].notna().sum() > 0
+
+        X = df["review_text"]
+        results = {}
+        pipes = {}
+        models_to_run = (["logistic","random_forest","xgboost"]
+                         if model_type == "all" else [model_type])
+
+        # Train/test split ถ้ามี label
+        if has_label:
+            y = df["sentiment"].fillna("Neutral")
+            if len(df) >= 20:
+                X_tr, X_te, y_tr, y_te = train_test_split(
+                    X, y, test_size=0.2, random_state=42,
+                    stratify=y if y.value_counts().min() >= 2 else None)
+            else:
+                X_tr, X_te, y_tr, y_te = X, X, y, y
+        else:
+            # ไม่มี label → train ด้วย rule-based pseudo labels
+            def rule_label(text):
+                tl = text.lower()
+                pos_w = ["ดี","เยี่ยม","ประทับใจ","แนะนำ","คุ้ม","ชอบ",
+                         "excellent","great","perfect","love","good","satisfied"]
+                neg_w = ["แย่","ผิดหวัง","ห่วย","ช้า","เสีย","ไม่ดี",
+                         "terrible","worst","poor","bad","horrible","disappointed"]
+                p = sum(1 for w in pos_w if w in tl)
+                n = sum(1 for w in neg_w if w in tl)
+                return "Positive" if p > n else "Negative" if n > p else "Neutral"
+            y = X.apply(rule_label)
+            X_tr, X_te, y_tr, y_te = X, X, y, y
+
+        for m_name in models_to_run:
+            if m_name == "logistic":
+                clf = LogisticRegression(max_iter=1000, C=0.5, random_state=42)
+                label = "Logistic + TF-IDF"
+            elif m_name == "random_forest":
+                clf = RandomForestClassifier(n_estimators=100, random_state=42)
+                label = "Random Forest + TF-IDF"
+            else:
+                clf = GradientBoostingClassifier(n_estimators=100, random_state=42)
+                label = "XGBoost + TF-IDF"
+
+            pipe = Pipeline([
+                ("tfidf", TfidfVectorizer(max_features=1500, ngram_range=(1,2),
+                                          sublinear_tf=True, min_df=1)),
+                ("clf", clf)
+            ])
+            pipe.fit(X_tr, y_tr)
+            y_pred = pipe.predict(X_te)
+
+            perf = {}
+            if has_label and len(set(y_te)) > 1:
+                perf = {
+                    "accuracy_pct": round(accuracy_score(y_te,y_pred)*100, 1),
+                    "f1_macro_pct": round(f1_score(y_te,y_pred,average="macro",zero_division=0)*100, 1),
+                    "f1_weighted_pct": round(f1_score(y_te,y_pred,average="weighted",zero_division=0)*100, 1),
+                }
+                # Confusion matrix
+                labels_order = ["Positive","Neutral","Negative"]
+                labels_present = [l for l in labels_order if l in set(y_te)]
+                cm = confusion_matrix(y_te, y_pred, labels=labels_present)
+                perf["confusion_matrix"] = {
+                    "labels": labels_present,
+                    "matrix": cm.tolist()
+                }
+
+            # Top keywords per class via TF-IDF
+            tfidf_step = pipe.named_steps["tfidf"]
+            feature_names = tfidf_step.get_feature_names_out()
+            keywords = {}
+            for cls in ["Positive","Negative","Neutral"]:
+                mask = y_tr == cls
+                if mask.sum() > 0:
+                    vecs = tfidf_step.transform(X_tr[mask])
+                    mean_sc = vecs.mean(axis=0).A1
+                    top_idx = mean_sc.argsort()[-10:][::-1]
+                    keywords[cls] = [str(feature_names[i]) for i in top_idx
+                                     if len(str(feature_names[i])) > 1][:8]
+
+            results[m_name] = {
+                "model_name": label,
+                "performance": perf,
+                "keywords": keywords,
+            }
+            pipes[m_name] = pipe
+
+        # ── Best model → predict all ──
+        best_name = (model_type if model_type != "all" else "logistic")
+        if best_name not in pipes:
+            best_name = list(pipes.keys())[0]
+        best_pipe = pipes[best_name]
+
+        all_preds = best_pipe.predict(X)
+        all_proba = best_pipe.predict_proba(X)
+        all_classes = best_pipe.classes_
+
+        # ── Build predictions list ──
+        predictions = []
+        for i, row in df.iterrows():
+            prob_arr = all_proba[i]
+            pred = all_preds[i]
+            conf = float(prob_arr.max())
+            prob_dict = {c: round(float(p)*100,1)
+                         for c,p in zip(all_classes, prob_arr)}
+            predictions.append({
+                "review_id": str(row.get("review_id", f"REV{i:04d}")),
+                "review_text": str(row.get("review_text",""))[:200],
+                "channel": str(row.get("channel","")),
+                "branch": str(row.get("branch","")),
+                "category": str(row.get("category","")),
+                "date": str(row.get("date","")),
+                "rating": int(row["rating"]) if "rating" in row and pd.notna(row.get("rating")) else None,
+                "actual_sentiment": str(row.get("sentiment","")) if has_label else None,
+                "predicted_sentiment": pred,
+                "confidence": round(conf, 3),
+                "probabilities": prob_dict,
+            })
+
+        # ── Summary stats ──
+        pred_counts = Counter(all_preds)
+        total = len(predictions)
+        sentiment_summary = {
+            "Positive": pred_counts.get("Positive",0),
+            "Neutral":  pred_counts.get("Neutral",0),
+            "Negative": pred_counts.get("Negative",0),
+            "positive_pct": round(pred_counts.get("Positive",0)/total*100,1),
+            "neutral_pct":  round(pred_counts.get("Neutral",0)/total*100,1),
+            "negative_pct": round(pred_counts.get("Negative",0)/total*100,1),
+            "net_sentiment_score": round(
+                (pred_counts.get("Positive",0) - pred_counts.get("Negative",0))/total*100, 1)
+        }
+
+        # ── Channel breakdown ──
+        channel_breakdown = {}
+        if "channel" in df.columns:
+            for ch in df["channel"].dropna().unique():
+                mask = df["channel"] == ch
+                ch_preds = [p["predicted_sentiment"] for p, m in
+                            zip(predictions, mask) if m]
+                c2 = Counter(ch_preds)
+                n = len(ch_preds)
+                channel_breakdown[ch] = {
+                    "total": n,
+                    "Positive": c2.get("Positive",0),
+                    "Negative": c2.get("Negative",0),
+                    "Neutral":  c2.get("Neutral",0),
+                    "positive_pct": round(c2.get("Positive",0)/n*100,1) if n else 0,
+                    "negative_pct": round(c2.get("Negative",0)/n*100,1) if n else 0,
+                }
+
+        # ── Branch breakdown ──
+        branch_breakdown = {}
+        if "branch" in df.columns:
+            for br in df["branch"].dropna().unique():
+                mask = df["branch"] == br
+                br_preds = [p["predicted_sentiment"] for p, m in
+                            zip(predictions, mask) if m]
+                c3 = Counter(br_preds)
+                n = len(br_preds)
+                branch_breakdown[br] = {
+                    "total": n,
+                    "Positive": c3.get("Positive",0),
+                    "Negative": c3.get("Negative",0),
+                    "Neutral":  c3.get("Neutral",0),
+                    "negative_pct": round(c3.get("Negative",0)/n*100,1) if n else 0,
+                }
+
+        # ── Monthly trend ──
+        monthly_trend = {}
+        if "month" in df.columns:
+            for mo in sorted(df["month"].dropna().unique()):
+                mask = df["month"] == mo
+                mo_preds = [p["predicted_sentiment"] for p, m in
+                            zip(predictions, mask) if m]
+                c4 = Counter(mo_preds)
+                monthly_trend[mo] = {
+                    "Positive": c4.get("Positive",0),
+                    "Negative": c4.get("Negative",0),
+                    "Neutral":  c4.get("Neutral",0),
+                }
+
+        # ── Avg rating by sentiment ──
+        avg_rating = {}
+        if "rating" in df.columns:
+            for s in ["Positive","Negative","Neutral"]:
+                mask = [p["predicted_sentiment"]==s for p in predictions]
+                ratings = [p["rating"] for p, m in zip(predictions, mask)
+                           if m and p["rating"] is not None]
+                avg_rating[s] = round(np.mean(ratings),2) if ratings else None
+
+        elapsed = round(time.time()-t0, 1)
+        print(f"✅ sentiment/analyze: {total}reviews model={model_type} t={elapsed}s")
+
+        # Comparison (if all)
+        comparison = []
+        for m_name, m_res in results.items():
+            if m_res.get("performance"):
+                comparison.append({
+                    "model": m_res["model_name"],
+                    "accuracy_pct": m_res["performance"].get("accuracy_pct",0),
+                    "f1_macro_pct": m_res["performance"].get("f1_macro_pct",0),
+                })
+
+        # Rule-based baseline
+        pos_w = ["ดี","เยี่ยม","ประทับใจ","excellent","great","love","good"]
+        neg_w = ["แย่","ผิดหวัง","ห่วย","terrible","worst","poor","bad"]
+        rule_preds = []
+        for text in X:
+            tl = text.lower()
+            p = sum(1 for w in pos_w if w in tl)
+            n = sum(1 for w in neg_w if w in tl)
+            rule_preds.append("Positive" if p>n else "Negative" if n>p else "Neutral")
+        if has_label:
+            rule_acc = round(accuracy_score(y, rule_preds)*100,1)
+            comparison.append({
+                "model": "Rule-based (Baseline)",
+                "accuracy_pct": rule_acc,
+                "f1_macro_pct": round(f1_score(y, rule_preds, average="macro",zero_division=0)*100,1)
+            })
+
+        return jsonify({
+            "total_reviews": total,
+            "model_requested": model_type,
+            "best_model": best_name,
+            "processing_time_sec": elapsed,
+            "has_label": has_label,
+            "sentiment_summary": sentiment_summary,
+            "channel_breakdown": channel_breakdown,
+            "branch_breakdown": branch_breakdown,
+            "monthly_trend": monthly_trend,
+            "avg_rating_by_sentiment": avg_rating,
+            "model_results": results,
+            "comparison": comparison,
+            "predictions": predictions,
+            "top_negative": sorted(
+                [p for p in predictions if p["predicted_sentiment"]=="Negative"],
+                key=lambda x: x["confidence"], reverse=True)[:10],
+            "top_positive": sorted(
+                [p for p in predictions if p["predicted_sentiment"]=="Positive"],
+                key=lambda x: x["confidence"], reverse=True)[:5],
+        })
+
+    except Exception as e:
+        import traceback; print(traceback.format_exc())
+        return jsonify({"error": str(e)}), 500
+
+
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
     app.run(host="0.0.0.0", port=port)