Update app.py

app.py

@@ -1,5 +1,6 @@
 import os
 import json
+import re
 import gradio as gr
 import torch
 import pandas as pd
@@ -7,19 +8,15 @@ from scipy.sparse import csr_matrix
 from sklearn.feature_extraction.text import TfidfVectorizer
 import open_clip
 
-# ==========================
-# 🔥 DEVICE
-# ==========================
+# 📌 Vérifier si CUDA est disponible
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🔹 Utilisation du périphérique : {device}")
 
-# ==========================
-# 🔥 CHARGEMENT OPENCLIP ViT-H/14
-# ==========================
+# 📌 Chargement du modèle OpenCLIP
 print("🔄 Chargement du modèle OpenCLIP ViT-H/14...")
 
 model_name = "ViT-H-14"
-pretrained = "laion2b_s32b_b79k"   # meilleur checkpoint
+pretrained = "laion2b_s32b_b79k"
 
 model, _, preprocess = open_clip.create_model_and_transforms(
     model_name,
@@ -31,114 +28,109 @@ tokenizer = open_clip.get_tokenizer(model_name)
 model = model.to(device)
 model.eval()
 
-print("✅ OpenCLIP chargé avec succès !")
+print("✅ Modèle OpenCLIP chargé avec succès !")
 
-# ==========================
-# 🔥 JSON produits
-# ==========================
+# 📌 Définition des fichiers JSON
 PRODUCTS_FILE = "products.json"
 QA_FILE = "qa_sequences_output.json"
 
-def safe_load_json(path):
-    if not os.path.exists(path):
-        print(f"⛔ Fichier introuvable : {path}")
+# 📌 Fonction pour charger les fichiers JSON
+def safe_load_json(file_path):
+    if not os.path.exists(file_path):
+        print(f"⛔ Fichier introuvable : {file_path}")
         return []
     try:
-        with open(path, "r", encoding="utf-8") as f:
+        with open(file_path, "r", encoding="utf-8") as f:
             data = json.load(f)
             return data.get("products", []) if "products" in data else data
-    except:
-        print(f"⚠️ Erreur JSON dans {path}")
+    except json.JSONDecodeError:
+        print(f"⚠️ Erreur de décodage JSON dans {file_path}")
         return []
 
 products_data = safe_load_json(PRODUCTS_FILE)
 qa_data = safe_load_json(QA_FILE)
 
-# ==========================
-# 🔥 EMBEDDINGS TEXTE (OpenCLIP)
-# ==========================
+# 📌 Générer des embeddings pour les produits
 def get_text_embeddings(texts):
+    """Génère des embeddings via OpenCLIP (même logique que ton code Marqo)."""
     with torch.no_grad():
+        # Tokenisation
         tokens = tokenizer(texts).to(device)
 
-        features = model.encode_text(tokens)
+        # Encodage texte
+        embeddings = model.encode_text(tokens)
 
-        # Normalisation L2 → très important pour cosine
-        features /= features.norm(dim=-1, keepdim=True)
+        # Normalisation
+        embeddings = embeddings / embeddings.norm(dim=-1, keepdim=True)
 
-    return features.cpu().numpy()
-
-# ==========================
-# 🔥 EMBEDDING PRODUITS
-# ==========================
-print("🛠️ Génération embeddings produits...")
+    return embeddings.cpu().numpy()
 
+# Création des embeddings pour tous les produits
+print("🛠️ Génération des embeddings des produits...")
 product_embeddings = get_text_embeddings([
-    p["title"] + " " + p["description"]
-    for p in products_data
+    prod["title"] + " " + prod["description"]
+    for prod in products_data
 ])
+print("✅ Embeddings générés et sauvegardés !")
 
-print("✅ Embeddings produits générés !")
-
-# ==========================
-# 🔥 TF-IDF
-# ==========================
+# 📌 TF-IDF Vectorizer pour une recherche hybride
 vectorizer = TfidfVectorizer(stop_words="english")
-
 tfidf_matrix = vectorizer.fit_transform([
-    p["title"] + " " + p["description"]
-    for p in products_data
+    prod["title"] + " " + prod["description"]
+    for prod in products_data
 ])
 
-# ==========================
-# 🔥 RECHERCHE HYBRIDE
-# ==========================
+# 📌 Recherche hybride avec OpenCLIP embeddings + TF-IDF
 def search_products(query, category, min_price, max_price,
-                    weight_tfidf=0.5, weight_embed=0.5):
+                    weight_tfidf=0.5, weight_openclip=0.5):
 
     if not query.strip():
-        return "❌ Veuillez entrer un terme valide."
+        return "❌ Veuillez entrer un terme de recherche valide."
 
-    min_price = float(min_price) if min_price else 0
-    max_price = float(max_price) if max_price else float("inf")
+    min_price = float(min_price) if isinstance(min_price, (int, float)) else 0
+    max_price = float(max_price) if isinstance(max_price, (int, float)) else float("inf")
 
-    # Embedding requête
-    q_emb = get_text_embeddings([query])[0]
+    # 📌 Embedding requête
+    query_embedding = get_text_embeddings([query])[0]
 
-    # Cosine similarity = dot product car vecteurs normalisés
-    clip_scores = (product_embeddings @ q_emb).tolist()
+    # 📌 Cosine similarity (dot product car vecteurs normalisés)
+    clip_scores = (product_embeddings @ query_embedding).tolist()
 
-    # TF-IDF similarity
-    query_vec = vectorizer.transform([query])
-    tfidf_scores = (tfidf_matrix @ query_vec.T).toarray().flatten()
+    # 📌 TF-IDF Similarité
+    query_vector_sparse = csr_matrix(vectorizer.transform([query]))
+    tfidf_scores = (tfidf_matrix * query_vector_sparse.T).toarray().flatten()
 
-    # Normalisation
-    def norm(x):
-        return (x - x.min()) / (x.max() - x.min() + 1e-6)
+    # 📌 Normalisation
+    def normalize(v):
+        v = pd.Series(v)
+        return (v - v.min()) / (v.max() - v.min() + 1e-6)
 
-    clip_scores = norm(pd.Series(clip_scores))
-    tfidf_scores = norm(pd.Series(tfidf_scores))
+    clip_scores = normalize(clip_scores)
+    tfidf_scores = normalize(tfidf_scores)
 
-    final = weight_tfidf * tfidf_scores + weight_embed * clip_scores
+    # 📌 Fusion
+    final_scores = weight_tfidf * tfidf_scores + weight_openclip * clip_scores
 
-    df = pd.DataFrame(products_data)
-    df["score"] = final.values
+    # 📌 DataFrame résultats
+    results_df = pd.DataFrame(products_data)
+    results_df["score"] = final_scores
 
-    # Filtres
-    df = df[
-        (df["price"].astype(float).fillna(0) >= min_price) &
-        (df["price"].astype(float).fillna(0) <= max_price) &
-        (df["availability"].fillna("").str.lower() == "in stock")
+    # 📌 Filtrage prix + dispo
+    results_df = results_df[
+        (results_df["price"].fillna(0).astype(float) >= min_price) &
+        (results_df["price"].fillna(0).astype(float) <= max_price) &
+        (results_df["availability"].fillna("").str.lower() == "in stock")
     ]
 
-    if category and category.lower() != "toutes":
-        df = df[df["category"].str.contains(category, case=False, na=False)]
+    # 📌 Filtrer par catégorie
+    if category and category != "Toutes":
+        results_df = results_df[
+            results_df["category"].str.contains(category, case=False, na=False)
+        ]
 
-    return df.sort_values("score", ascending=False).head(20)
+    return results_df.sort_values(by="score", ascending=False).head(20)
 
-# ==========================
-# 🔥 INTERFACE GRADIO
-# ==========================
+# 📌 Interface Gradio
 app = gr.Interface(
     fn=search_products,
     inputs=[
@@ -151,11 +143,7 @@ app = gr.Interface(
         gr.Dataframe(headers=[
             "ID", "Titre", "Description", "Prix", "Disponibilité", "Score"
         ])
-    ],
-    title="🔍 Recherche IA e-commerce avec OpenCLIP",
-    description="Moteur de recherche hybride basé sur OpenCLIP ViT-H/14 + TF-IDF"
+    ]
 )
 
-if __name__ == "__main__":
-    print("🚀 Lancement interface...")
-    app.launch()
+app.launch()