Refactor explainer methods and enhance evaluation template with detailed CF approach explanations

app.py

@@ -41,11 +41,6 @@ for _, u in users.iterrows():
 CATEGORIES = sorted(products["category"].unique().tolist())
 BRANDS = sorted(products["brand"].unique().tolist())
 
-for _ in cf_train.train_svd_generator():
-    pass
-for _ in cf_train.compute_slope_one_dev_generator():
-    pass
-
 APPROACHES = {
     "cf": {
         "label": "Collaborative Filtering",

recommender/explainer.py

@@ -15,45 +15,78 @@ class Explainer:
     def _get_user(self, user_id):
         return self._user_cache.get(user_id, {})
 
+    def _fmt_score(self, score):
+        if score >= 0.9:
+            return "Excellent match"
+        elif score >= 0.7:
+            return "Strong match"
+        elif score >= 0.5:
+            return "Good match"
+        elif score >= 0.3:
+            return "Moderate match"
+        else:
+            return "Partial match"
+
+    def _pref_list(self, user, key):
+        raw = user.get(key, "")
+        if raw is None or isinstance(raw, float):
+            return []
+        if isinstance(raw, str):
+            return [p.strip() for p in raw.split(",") if p.strip()][:2]
+        return list(raw)[:2] if raw else []
+
     def explain_cf(self, method, user_id, product_id, details=None):
         product = self._get_product(product_id)
-        product_name = product.get("name", f"Item #{product_id}")
+        user = self._get_user(user_id)
+        pname = product.get("name", f"Item #{product_id}")
+        cat = product.get("category", "")
+        brand = product.get("brand", "")
+        price = product.get("price", 0)
         details = details or {}
-
         sim = min(details.get('sim_score', 0), 1.0)
+        pref_cats = self._pref_list(user, "preferred_categories")
+
         templates = {
-            "user_based": f"Recommended because {details.get('count', 'several')} similar users (avg {sim*100:.0f}% match) also purchased {product_name}",
-            "item_based": f"Recommended because it is {sim*100:.0f}% similar to items you liked",
-            "svd": f"Recommended based on your taste profile — {product_name} matches your latent preferences",
-            "knn": f"Recommended because {details.get('count', 'several')} nearest neighbors with similar taste purchased this",
-            "slope_one": f"Recommended based on average preference patterns for {product_name}",
+            "user_based": f"Users with {cat} taste also liked {pname}",
+            "item_based": f"Matches your {cat} preferences — similar to items you've rated highly",
+            "svd": f"Fits your profile: {brand}'s {cat} — top latent factor match" if brand and cat else f"Fits your profile: {cat} — top latent factor match",
+            "knn": f"Popular among peers who also like {cat}" if cat else f"Popular among users with similar taste",
+            "slope_one": f"Frequently chosen by users who liked the same {cat} products" if cat else f"Frequently chosen by users with your taste",
         }
         return templates.get(method, f"Recommended based on collaborative filtering")
 
     def explain_content(self, method, user_id, product_id, details=None):
         product = self._get_product(product_id)
-        product_name = product.get("name", f"Item #{product_id}")
-        category = product.get("category", "")
+        user = self._get_user(user_id)
+        pname = product.get("name", f"Item #{product_id}")
+        cat = product.get("category", "")
+        brand = product.get("brand", "")
+        sub = product.get("subcategory", "")
         details = details or {}
-
         score = min(details.get('score', 0), 1.0)
+        pref_cats = self._pref_list(user, "preferred_categories")
+
         templates = {
-            "tfidf": f"Recommended because {product_name} matches items you've liked before (content similarity: {score*100:.0f}%)",
-            "feature_match": f"Recommended because it matches your preferred category: {category}",
+            "tfidf": f"Content matches: {cat} / {sub} — strongly aligns with your past likes" if sub else f"Content matches your preferred {cat} items",
+            "feature_match": f"Matches your preferences: {cat}, {brand}" if brand else f"Matches your preferred category: {cat}",
         }
         return templates.get(method, f"Recommended based on item features")
 
     def explain_knowledge(self, method, user_id, product_id, details=None):
         product = self._get_product(product_id)
-        product_name = product.get("name", f"Item #{product_id}")
+        user = self._get_user(user_id)
+        pname = product.get("name", f"Item #{product_id}")
+        cat = product.get("category", "")
         brand = product.get("brand", "")
         price = product.get("price", 0)
+        budget_max = details.get("budget_max", 0)
         details = details or {}
+        pref_brands = self._pref_list(user, "favorite_brands")
 
         templates = {
-            "constraint": f"Recommended because {product_name} meets your criteria: budget ${details.get('budget_max', 'N/A')}, brand: {brand}",
-            "rule": f"Recommended because customers who bought {details.get('trigger_item', 'similar items')} also purchased {product_name}",
-            "utility": f"Recommended with {details.get('score', 0)*100:.1f}% utility match based on your preference weights",
+            "constraint": f"Fits your criteria: ${price:.0f} within budget · {cat} · {brand}" if brand else f"Fits your criteria: ${price:.0f} within budget · {cat}",
+            "rule": f"{cat} buyers commonly add {pname} — cross-sell match" if cat else f"Customers also purchased {pname}",
+            "utility": f"Top utility score: {cat} × {brand} matches your preference weights" if brand else f"Top utility score: {cat} matches your preference weights",
         }
         return templates.get(method, f"Recommended based on your requirements")
 

templates/evaluation.html

@@ -405,14 +405,40 @@
       buildBestMethodAnalysis() {
         const best = this.cfData.find(r => r.method === this.bestCfMethod);
         if (!best) return 'Run evaluation to find out.';
-        return `<strong>${methodLabels[this.bestCfMethod] || this.bestCfMethod}</strong> achieves the lowest RMSE (${best.RMSE.toFixed(4)}) among all CF methods. SVD (Matrix Factorization) typically performs best because it captures latent factors in the user-item interaction matrix, handling sparsity better than memory-based methods.`;
+
+        const methodExplanations = {
+          user_based: 'simplicity and direct peer comparison — works well when the target user has enough similar neighbors.',
+          item_based: 'direct item-item similarity — effective on dense data where co-rated item pairs are plentiful.',
+          svd: 'latent factor modeling — captures hidden patterns in the user-item matrix, excelling on sparse, large-scale data.',
+          knn: 'nearest-neighbor aggregation — robust to noise, but performance depends on the quality of the neighbor set.',
+          slope_one: 'simplicity and speed of prediction — performs well when rating deviations are consistent across users.',
+        };
+        const why = methodExplanations[this.bestCfMethod] || 'strong performance on this dataset.';
+
+        return `<strong>${methodLabels[this.bestCfMethod] || this.bestCfMethod}</strong> achieves the lowest RMSE (${best.RMSE.toFixed(4)}) among all CF methods. ` +
+               `${methodLabels[this.bestCfMethod] || this.bestCfMethod} excels because of ${why}`;
       },
 
       buildBestApproachAnalysis(data) {
         if (!data.best_approach) return 'Run evaluation to find out.';
         const bestApp = data.approaches?.find(a => a.approach === data.best_approach);
         const precVal = bestApp ? bestApp['Precision@5'].toFixed(4) : '—';
-        return `<strong>${data.best_approach}</strong> achieves the highest Precision@5 (${precVal}) on this dataset. Collaborative Filtering generally performs best when sufficient rating data exists. Content-Based works well for new items but suffers from overspecialization. Knowledge-Based excels in cold-start scenarios and when users have explicit constraints.`;
+        const second = [...(data.approaches || [])].sort((a, b) => (b['Precision@5'] || 0) - (a['Precision@5'] || 0));
+        const runnerUp = second.length > 1 ? second[1].approach : null;
+
+        const explanations = {
+          'Collaborative Filtering': `strongest when rating data is dense (${this.cfData.length} methods averaged). Works by leveraging peer behavior patterns.`,
+          'Content-Based': `best when item features are informative (${data.approaches?.length || 0} approaches compared). Shines for cold-start items and niche categories where collaborative signals are weak.`,
+          'Knowledge-Based': `ideal for cold-start users with explicit constraints. Deterministic and transparent, but limited by the quality of hand-crafted rules.`,
+        };
+        const why = explanations[data.best_approach] || 'strong performance on this dataset.';
+
+        let text = `<strong>${data.best_approach}</strong> achieves the highest Precision@5 (${precVal}) on this dataset. ` +
+                   `${data.best_approach} performs ${why}`;
+        if (runnerUp) {
+          text += ` <strong>${runnerUp}</strong> follows as the runner-up.`;
+        }
+        return text;
       },
 
       animateCounter(obj, key, target, decimals = 4, duration = 800) {