Upload app.py with huggingface_hub

app.py

@@ -10,28 +10,16 @@ from sentence_transformers import SentenceTransformer
 from fastapi import FastAPI
 from fastapi.middleware.wsgi import WSGIMiddleware
 import uvicorn
-import nest_asyncio
 
 # ===============================
-# OPTIONAL FAISS
+# CONFIG HF
 # ===============================
-try:
-    import faiss
-    FAISS_AVAILABLE = True
-    print("✅ FAISS available")
-except ImportError:
-    FAISS_AVAILABLE = False
-    print("⚠️ FAISS not available → torch fallback")
-
-# ===============================
-# CONFIG
-# ===============================
-BASE_DIR = os.path.abspath(os.path.dirname(__file__))
-CSV_DATA = "dataset_2026.csv"
-EMB_FILE = "embeddings_questions.pt"
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CSV_DATA = os.path.join(BASE_DIR, "dataset_2026.csv")
+EMB_FILE = os.path.join(BASE_DIR, "embeddings_questions.pt")
 
 TOP_K_RECOMMANDATIONS = 5
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DEVICE = "cpu"   # ⛔ FORCÉ CPU (HF)
 
 # ===============================
 # FLASK APP
@@ -43,74 +31,54 @@ app = Flask(
 )
 
 # ===============================
-# LOAD MODEL (ONCE)
+# LOAD MODEL (SAFE)
 # ===============================
-print("🔹 Loading embedding model...")
+print("🔹 Loading model (CPU only)...")
 model = SentenceTransformer(
-    "OrdalieTech/Solon-embeddings-mini-beta-1.1",
-    device=DEVICE,
-    trust_remote_code=True
+    "sentence-transformers/all-MiniLM-L6-v2",
+    device="cpu"
 )
 
 # ===============================
-# LOAD & CLEAN DATASET
+# LOAD DATASET
 # ===============================
 print("🔹 Loading dataset...")
-df = pd.read_csv(CSV_DATA, low_memory=False)
-
+df = pd.read_csv(CSV_DATA)
 df = df.dropna(subset=["question"]).reset_index(drop=True)
 
-if df.empty:
-    raise RuntimeError("❌ Dataset has no valid questions")
-
 questions = df["question"].astype(str).tolist()
 NB_QUESTIONS = len(questions)
 
-print(f"✅ Valid questions loaded: {NB_QUESTIONS}")
+print(f"✅ Questions loaded: {NB_QUESTIONS}")
 
 # ===============================
 # LOAD / CREATE EMBEDDINGS
 # ===============================
 if os.path.exists(EMB_FILE):
     print("🔹 Loading cached embeddings...")
-    emb_base = torch.load(EMB_FILE, map_location=DEVICE)
+    emb_base = torch.load(EMB_FILE, map_location="cpu")
 else:
     print("🔹 Computing embeddings...")
     emb_base = model.encode(
         questions,
         convert_to_tensor=True,
         normalize_embeddings=True,
-        batch_size=64
+        batch_size=32
     )
     torch.save(emb_base, EMB_FILE)
 
-# Safety check
-if emb_base.shape[0] != NB_QUESTIONS:
-    raise RuntimeError("❌ Embedding count mismatch")
-
-# ===============================
-# INDEX SETUP
-# ===============================
-K_SEARCH = max(1, min(TOP_K_RECOMMANDATIONS + 1, NB_QUESTIONS))
-
-if FAISS_AVAILABLE:
-    emb_np = emb_base.float().cpu().numpy()
-    dim = emb_np.shape[1]
-    index = faiss.IndexFlatIP(dim)
-    index.add(emb_np)
-else:
-    emb_base_cpu = emb_base.float().cpu()
+emb_base = emb_base.cpu()
 
 # ===============================
 # CACHE QUESTION EMBEDDING
 # ===============================
-@lru_cache(maxsize=1000)
+@lru_cache(maxsize=500)
 def encode_question_cached(q: str):
     return model.encode(
         q,
         convert_to_tensor=True,
         normalize_embeddings=True
-    ).float()
+    ).cpu()
 
 # ===============================
 # UTILS
@@ -119,7 +87,6 @@ def enrich_message(base):
     return random.choice([
         f"Bonne question 🙂 {base}",
         f"Voici ce que je peux vous dire : {base}",
-        f"Intéressant ! {base}",
         base
     ])
 
@@ -128,92 +95,32 @@ def enrich_message(base):
 # ===============================
 def process_question(question: str):
 
-    if not question or not question.strip():
-        return {
-            "response": "Veuillez poser une question.",
-            "confidence": 0,
-            "matched": "—",
-            "intent": "Vide",
-            "recs": []
-        }
+    if not question.strip():
+        return {"response": "Veuillez poser une question."}
 
-    emb_q = encode_question_cached(question)
+    emb_q = encode_question_cached(question).unsqueeze(0)
 
-    # ---------- FAISS SEARCH ----------
-    if FAISS_AVAILABLE:
-        D, I = index.search(
-            emb_q.cpu().numpy().reshape(1, -1),
-            K_SEARCH
-        )
-
-        if D.size == 0:
-            return {
-                "response": "Aucune réponse trouvée",
-                "confidence": 0,
-                "matched": "—",
-                "intent": "Inconnu",
-                "recs": []
-            }
-
-        idxs = I[0].tolist()
-        scores = D[0].tolist()
-
-    # ---------- TORCH FALLBACK ----------
-    else:
-        if emb_q.dim() == 1:
-            emb_q = emb_q.unsqueeze(0)
-
-        emb_q = emb_q.float()
-
-        scores_all = torch.matmul(
-            emb_q,
-            emb_base_cpu.T
-        ).squeeze(0)
-
-        k = min(K_SEARCH, scores_all.numel())
-        values, indices = torch.topk(scores_all, k)
-
-        idxs = indices.tolist()
-        scores = values.tolist()
-
-    # ---------- DECISION ----------
-    best_idx = idxs[0]
-    confidence = int(scores[0] * 100)
-
-    if confidence < 40:
-        return {
-            "response": "Aucune réponse trouvée",
-            "confidence": confidence,
-            "matched": "—",
-            "intent": "Inconnu",
-            "recs": []
-        }
+    scores = torch.matmul(emb_q, emb_base.T).squeeze(0)
+    values, indices = torch.topk(scores, k=min(TOP_K_RECOMMANDATIONS + 1, len(scores)))
 
-    if confidence < 80:
-        recs = [
-            df["question"].iloc[i]
-            for i in idxs[1:]
-            if i < NB_QUESTIONS
-        ][:TOP_K_RECOMMANDATIONS]
+    best_idx = indices[0].item()
+    confidence = int(values[0].item() * 100)
 
+    if confidence < 50:
         return {
-            "response": "Je ne suis pas totalement sûr. Voici des questions proches :",
-            "confidence": confidence,
-            "matched": df["question"].iloc[best_idx],
-            "intent": "Incertain",
-            "recs": recs
+            "response": "Je ne suis pas sûr de la réponse.",
+            "confidence": confidence
         }
 
     return {
         "response": enrich_message(df["rationale"].iloc[best_idx]),
         "confidence": confidence,
         "matched": df["question"].iloc[best_idx],
-        "intent": df["intent"].iloc[best_idx],
-        "recs": []
+        "intent": df["intent"].iloc[best_idx]
     }
 
 # ===============================
-# FLASK ROUTES
+# ROUTES
 # ===============================
 @app.route("/")
 def index():
@@ -221,12 +128,12 @@ def index():
 
 @app.route("/ask", methods=["POST"])
 def ask():
-    data = request.get_json(silent=True) or {}
+    data = request.get_json() or {}
     question = data.get("question", "")
     return jsonify(process_question(question))
 
 # ===============================
-# FASTAPI WRAPPER
+# FASTAPI WRAPPER (HF)
 # ===============================
 fastapi_app = FastAPI()
 fastapi_app.mount("/", WSGIMiddleware(app))
@@ -235,6 +142,6 @@ fastapi_app.mount("/", WSGIMiddleware(app))
 # MAIN
 # ===============================
 if __name__ == "__main__":
-    nest_asyncio.apply()
-    print("🚀 Server running on http://localhost:7860")
-    uvicorn.run(fastapi_app, host="0.0.0.0", port=7860)
+    port = int(os.environ.get("PORT", 7860))
+    print(f"🚀 Running on port {port}")
+    uvicorn.run(fastapi_app, host="0.0.0.0", port=port)