ChangedLogicToPredictSum

Co-authored-by: Copilot <copilot@github.com>

app.py

@@ -679,12 +679,17 @@ def predict_expenses_endpoint():
     """Predicts top 3 expenses user should add based on 6-month history."""
     payload = parse_json_payload()
     expenses = payload.get("expenses") or []
+    user_id = payload.get("user_id")
+    debug = (request.args.get("debug") or request.args.get("debut") or "").strip().lower() == ""
     
     if not isinstance(expenses, list):
         return jsonify({"status": "error", "message": "expenses must be a list"}), 422
+
+    if user_id is None:
+        return jsonify({"status": "error", "message": "user_id is required"}), 422
     
     try:
-        predictions = predict_expenses(expenses)
+        predictions = predict_expenses(expenses, target_user_id=user_id, debug=debug)
         return jsonify({
             "status": "ok",
             "predictions": predictions

expense_predictor.py

@@ -4,99 +4,143 @@ Expense prediction model: suggests next expenses based on 6-month history.
 - Output: Top 3 predicted expenses (date, sum, supplier, user)
 """
 
-from datetime import datetime, timedelta
+from datetime import datetime
 from collections import defaultdict
-from typing import Optional
 import statistics
 
+from sklearn.ensemble import RandomForestRegressor
 
-def predict_expenses(expenses: list[dict]) -> list[dict]:
-    """
-    Predict top 3 expenses user should add.
-    
-    Input: [{"date": "2026-01-15", "sum": 150.50, "supplier_id": 5, "user_id": 1, ...}, ...]
-    Output: [{"date": str, "sum": float, "supplier_id": int, "user_id": int, "confidence": float}, ...]
-    """
+
+def predict_expenses(expenses: list[dict], target_user_id, debug: bool = False) -> list[dict]:
     if not expenses or len(expenses) < 2:
-        print(f"[PREDICT] Not enough records: {len(expenses) if expenses else 0}")
+        if debug:
+            print(f"[PREDICT] Not enough records: {len(expenses) if expenses else 0}")
         return []
 
-    # Group by (supplier_id, user_id)
-    supplier_user_history = defaultdict(list)
+    # Group by supplier_id (top-3 different suppliers)
+    supplier_history = defaultdict(list)
     supplier_freq = defaultdict(int)
     total_records = len(expenses)
 
-    print(f"[PREDICT] Total records received: {total_records}")
-    for i, exp in enumerate(expenses):
-        print(f"[PREDICT]   [{i+1}] date={exp.get('date')}, sum={exp.get('sum')}, supplier_id={exp.get('supplier_id')}, user_id={exp.get('user_id')}")
+    if debug:
+        print(f"[PREDICT] Total records received: {total_records}")
+        for i, exp in enumerate(expenses):
+            print(f"[PREDICT]   [{i+1}] date={exp.get('date')}, sum={exp.get('sum')}, supplier_id={exp.get('supplier_id')}, user_id={exp.get('user_id')}")
 
     for exp in expenses:
-        key = (exp["supplier_id"], exp["user_id"])
-        supplier_user_history[key].append(exp)
-        supplier_freq[key] += 1
-
-    print(f"[PREDICT] Unique (supplier, user) pairs: {len(supplier_user_history)}")
-    for key, count in supplier_freq.items():
-        pct = count / total_records * 100
-        print(f"[PREDICT]   supplier_id={key[0]}, user_id={key[1]} → {count} records ({pct:.1f}%)")
-
-    # Filter: frequency > 50% over 6 months
-    candidates = {
-        key: records
-        for key, records in supplier_user_history.items()
-        if supplier_freq[key] / total_records >= 0.5
-    }
-
-    print(f"[PREDICT] Candidates after >50% filter: {len(candidates)}")
-
-    if not candidates:
-        print("[PREDICT] No candidates passed the frequency filter. Returning empty.")
+        supplier_id = exp["supplier_id"]
+        supplier_history[supplier_id].append(exp)
+        supplier_freq[supplier_id] += 1
+
+    if debug:
+        print(f"[PREDICT] Unique suppliers: {len(supplier_history)}")
+        for supplier_id, count in supplier_freq.items():
+            pct = count / total_records * 100
+            print(f"[PREDICT]   supplier_id={supplier_id} -> {count} records ({pct:.1f}%)")
+
+    # Keep only top 3 suppliers by frequency (different suppliers)
+    candidates = supplier_history
+    top_candidate_items = sorted(
+        candidates.items(),
+        key=lambda item: supplier_freq[item[0]],
+        reverse=True,
+    )[:3]
+
+    if debug:
+        print(f"[PREDICT] Processing top {len(top_candidate_items)} suppliers by frequency")
+
+    if not top_candidate_items:
+        if debug:
+            print("[PREDICT] No suppliers found. Returning empty.")
         return []
 
-    # Analyze each candidate: avg amount, interval, last date
+    now = datetime.now()
+
+    # Build one regression model for sum prediction.
+    supplier_to_idx = {supplier_id: idx for idx, supplier_id in enumerate(supplier_history.keys())}
+    user_values = [exp.get("user_id") for exp in expenses if exp.get("user_id") is not None]
+    user_to_idx = {user_id: idx for idx, user_id in enumerate(sorted(set(user_values), key=str))}
+
+    X_train = []
+    y_train = []
+
+    for exp in expenses:
+        supplier_id = exp.get("supplier_id")
+        user_id = exp.get("user_id")
+        raw_date = exp.get("date")
+        raw_sum = exp.get("sum")
+        if supplier_id is None or user_id is None or raw_date is None or raw_sum is None:
+            continue
+
+        tx_date = datetime.fromisoformat(raw_date)
+        X_train.append([
+            supplier_to_idx.get(supplier_id, -1),
+            user_to_idx.get(user_id, -1),
+            tx_date.day,
+            tx_date.weekday(),
+            tx_date.month,
+        ])
+        y_train.append(float(raw_sum))
+
+    sum_model = None
+    if len(X_train) >= 5:
+        sum_model = RandomForestRegressor(n_estimators=300, random_state=42)
+        sum_model.fit(X_train, y_train)
+
+    # Predict only amount for each of top-3 suppliers.
     predictions = []
 
-    for (supplier_id, user_id), records in candidates.items():
+    for supplier_id, records in top_candidate_items:
+        records = sorted(records, key=lambda r: datetime.fromisoformat(r["date"]))
         amounts = [float(r["sum"]) for r in records]
         avg_amount = statistics.mean(amounts)
 
-        # Calculate interval between transactions (days)
-        dates = sorted([datetime.fromisoformat(r["date"]) for r in records])
-        if len(dates) >= 2:
-            intervals = [(dates[i+1] - dates[i]).days for i in range(len(dates) - 1)]
-            avg_interval = statistics.mean(intervals)
+        next_features = [[
+            supplier_to_idx.get(supplier_id, -1),
+            user_to_idx.get(target_user_id, -1),
+            now.day,
+            now.weekday(),
+            now.month,
+        ]]
+
+        if sum_model is not None:
+            predicted_amount = float(sum_model.predict(next_features)[0])
+            model_conf = 0.8
         else:
-            avg_interval = 30  # default monthly
+            predicted_amount = avg_amount
+            model_conf = 0.5
 
-        last_date = dates[-1]
-        next_predicted_date = (last_date + timedelta(days=avg_interval)).strftime("%Y-%m-%d")
+        next_predicted_date = now.strftime("%Y-%m-%d")
+        predicted_user = target_user_id
 
-        # Confidence: higher if more consistent (lower std dev)
         amount_std = statistics.stdev(amounts) if len(amounts) > 1 else 0
         consistency = max(0, 1 - (amount_std / avg_amount)) if avg_amount > 0 else 0.5
-        frequency_score = min(supplier_freq[(supplier_id, user_id)] / total_records, 1.0)
-        confidence = (consistency + frequency_score) / 2
-
-        print(
-            f"[PREDICT] supplier_id={supplier_id}, user_id={user_id} | "
-            f"avg_amount={avg_amount:.2f}, avg_interval={avg_interval:.1f}d, "
-            f"last_date={last_date.date()}, next_date={next_predicted_date}, "
-            f"consistency={consistency:.2f}, freq_score={frequency_score:.2f}, confidence={confidence:.2f}"
-        )
-        
+        frequency_score = min(supplier_freq[supplier_id] / total_records, 1.0)
+        confidence = (0.4 * consistency) + (0.3 * frequency_score) + (0.3 * model_conf)
+
+        if debug:
+            print(
+                f"[PREDICT] supplier_id={supplier_id}, user_id={predicted_user} | "
+                f"avg_amount={avg_amount:.2f}, pred_sum={predicted_amount:.2f}, "
+                f"target_date={next_predicted_date}, "
+                f"consistency={consistency:.2f}, freq_score={frequency_score:.2f}, "
+                f"model_conf={model_conf:.2f}, confidence={confidence:.2f}"
+            )
+
         predictions.append({
             "date": next_predicted_date,
-            "sum": round(avg_amount, 2),
+            "sum": round(max(0.0, predicted_amount), 2),
             "supplier_id": supplier_id,
-            "user_id": user_id,
+            "user_id": predicted_user,
             "confidence": round(confidence, 2)
         })
 
     # Return top 3 by confidence
     result = sorted(predictions, key=lambda x: x["confidence"], reverse=True)[:3]
 
-    print(f"[PREDICT] Final top {len(result)} predictions:")
-    for i, p in enumerate(result, 1):
-        print(f"[PREDICT]   #{i}: supplier_id={p['supplier_id']}, user_id={p['user_id']}, date={p['date']}, sum={p['sum']}, confidence={p['confidence']}")
+    if debug:
+        print(f"[PREDICT] Final top {len(result)} predictions:")
+        for i, p in enumerate(result, 1):
+            print(f"[PREDICT]   #{i}: supplier_id={p['supplier_id']}, user_id={p['user_id']}, date={p['date']}, sum={p['sum']}, confidence={p['confidence']}")
 
     return result