Update app.py

app.py

@@ -4,8 +4,8 @@ import re
 import gradio as gr
 import torch
 import pandas as pd
-import faiss
 import time
+import marqo
 from scipy.sparse import csr_matrix
 from transformers import AutoModel, AutoProcessor
 from sklearn.feature_extraction.text import TfidfVectorizer
@@ -38,18 +38,16 @@ for attempt in range(MAX_RETRIES):
             print("⛔ Échec final du chargement du modèle.")
             model, processor = None, None
 
-# Fonction pour charger et fusionner les données
+# Fonction pour charger les fichiers JSON
 def load_data():
     products_data, qa_data = [], []
 
-    # Charger les produits
     if os.path.exists(PRODUCTS_FILE):
         with open(PRODUCTS_FILE, "r", encoding="utf-8") as f:
             products_data = json.load(f).get("products", [])
     else:
         print(f"⛔ Fichier introuvable : {PRODUCTS_FILE}")
 
-    # Charger les questions-réponses
     if os.path.exists(QA_FILE):
         with open(QA_FILE, "r", encoding="utf-8") as f:
             qa_data = json.load(f)
@@ -61,10 +59,49 @@ def load_data():
 products_data, qa_data = load_data()
 
 # Associer les questions-réponses aux produits
+def associate_qa_with_products(products, qa_data):
+    for product in products:
+        product["qa_info"] = []
+        product_name = product.get("title", "").lower()
+        product_desc = product.get("description", "").lower()
+
+        for qa in qa_data:
+            question = qa.get("question", "").lower()
+            if product_name in question or product_desc in question:
+                product["qa_info"].append(qa)
+
+    return products
+
+products_data = associate_qa_with_products(products_data, qa_data)
+
+# Connexion au serveur Marqo
+mq = marqo.Client(url="http://localhost:8882")  # Port par défaut de Marqo
+INDEX_NAME = "ecommerce_products"
+
+# Supprimer et recréer l'index
+try:
+    mq.delete_index(INDEX_NAME)
+except:
+    pass
+
+mq.create_index(INDEX_NAME, settings={"index_defaults": {"model": "open_clip/ViT-B-32/laion2B-s34B-b79K"}})
+
+# Ajouter les produits à Marqo
+documents = []
 for product in products_data:
-    product_name = product.get("title", "").lower()
-    related_qa = [qa for qa in qa_data if product_name in qa.get("question", "").lower()]
-    product["qa_info"] = related_qa  # Ajouter les questions/réponses au produit
+    doc = {
+        "id": product["id"],
+        "title": product["title"],
+        "description": product["description"],
+        "price": product["price"],
+        "availability": product["availability"],
+        "category": product["category"],
+        "qa_info": product.get("qa_info", []),
+    }
+    documents.append(doc)
+
+mq.index(INDEX_NAME).add_documents(documents, tensor_fields=["title", "description"])
+print("✅ Produits indexés dans Marqo !")
 
 # Prétraitement du texte
 def preprocess(text: str) -> str:
@@ -73,74 +110,61 @@ def preprocess(text: str) -> str:
     text = re.sub(r'[^\w\s]', '', text)
     return text.strip()
 
-# Génération des embeddings des produits optimisée
-def get_text_embeddings(texts, batch_size=32):
-    if not texts:  # Vérifier que la liste de textes n'est pas vide
-        print("⚠️ Avertissement : Aucun texte à encoder. Retour d'une matrice vide.")
-        return torch.zeros((0, model.config.hidden_size)).numpy()
-    
-    with torch.no_grad():
-        processed_texts = processor(text=texts, return_tensors="pt", truncation=True, max_length=64, padding=True).to(device)
-        embeddings = model.get_text_features(processed_texts["input_ids"], normalize=True)
-    return embeddings.cpu().numpy()
-
-print("🛠️ Génération des embeddings des produits...")
-product_embeddings = get_text_embeddings([prod["title"] + " " + prod["description"] for prod in products_data])
-print("✅ Embeddings générés et sauvegardés !")
-
-# Optimisation FAISS avec index dynamique
-d = product_embeddings.shape[1]  
-nlist = max(10, len(product_embeddings) // 10)  # Ajuste dynamiquement le nombre de centroids
-
-if len(product_embeddings) < 4000:
-    index = faiss.IndexFlatL2(d)  # Index simple pour petits datasets
-else:
-    index = faiss.IndexIVFFlat(faiss.IndexFlatL2(d), d, nlist)
-    index.train(product_embeddings)
-
-index.add(product_embeddings)
-
 # TF-IDF Vectorizer
 vectorizer = TfidfVectorizer(stop_words="english")
 tfidf_matrix = vectorizer.fit_transform([prod["title"] + " " + prod["description"] for prod in products_data])
 
-# Recherche hybride optimisée avec pondération
-def search_products(query, category, min_price, max_price, weight_tfidf=0.5, weight_faiss=0.5):
+# Recherche hybride avec Marqo + TF-IDF
+def search_products(query, category, min_price, max_price, weight_tfidf=0.5, weight_marqo=0.5):
     query = preprocess(query)
-    
+
+    # Recherche Marqo (top 50 résultats)
+    marqo_results = mq.index(INDEX_NAME).search(query, searchable_attributes=["title", "description"], limit=50)
+
+    # Récupérer les résultats Marqo
+    marqo_products = []
+    marqo_scores = []
+    for hit in marqo_results["hits"]:
+        marqo_products.append(hit)
+        marqo_scores.append(hit["_score"])
+
+    # Normaliser les scores Marqo
+    if len(marqo_scores) > 0:
+        marqo_scores = (pd.Series(marqo_scores) - min(marqo_scores)) / (max(marqo_scores) - min(marqo_scores) + 1e-6)
+    else:
+        marqo_scores = [0] * len(marqo_products)
+
     # TF-IDF Similarité
-    query_vector_sparse = csr_matrix(vectorizer.transform([query]))  
+    query_vector_sparse = csr_matrix(vectorizer.transform([query]))
     tfidf_scores = (tfidf_matrix * query_vector_sparse.T).toarray().flatten()
-    
-    # FAISS Similarité
-    query_embedding = get_text_embeddings([query])[0].reshape(1, -1)
-    _, indices = index.search(query_embedding, 50)
-    
-    # Récupérer les produits similaires
-    similar_products = pd.DataFrame([products_data[i] for i in indices[0]])
-    
-    # Normalisation des scores
-    tfidf_scores_norm = (tfidf_scores - tfidf_scores.min()) / (tfidf_scores.max() - tfidf_scores.min() + 1e-6)
-    
-    # Ajout du score pondéré
-    similar_products["score"] = weight_tfidf * tfidf_scores_norm[indices[0]] + weight_faiss * (1 - tfidf_scores_norm[indices[0]])
-
-    # Filtrage par prix et disponibilité
-    filtered_results = similar_products[
-        (similar_products["price"] >= min_price) &
-        (similar_products["price"] <= max_price) &
-        (similar_products["availability"] == "in stock")
+
+    # Normaliser les scores TF-IDF
+    if len(tfidf_scores) > 0:
+        tfidf_scores_norm = (tfidf_scores - min(tfidf_scores)) / (max(tfidf_scores) - min(tfidf_scores) + 1e-6)
+    else:
+        tfidf_scores_norm = [0] * len(marqo_products)
+
+    # Fusionner les scores TF-IDF et Marqo
+    final_scores = weight_tfidf * tfidf_scores_norm[:len(marqo_products)] + weight_marqo * marqo_scores
+
+    # Ajouter le score final aux produits
+    for i, product in enumerate(marqo_products):
+        product["score"] = final_scores[i]
+
+    # Convertir en DataFrame
+    results_df = pd.DataFrame(marqo_products)
+
+    # Filtrer les résultats par prix et disponibilité
+    results_df = results_df[
+        (results_df["price"] >= min_price) &
+        (results_df["price"] <= max_price) &
+        (results_df["availability"] == "in stock")
     ]
-    
+
     if category and category != "Toutes":
-        filtered_results = filtered_results[filtered_results["category"].str.contains(category, case=False, na=False)]
+        results_df = results_df[results_df["category"].str.contains(category, case=False, na=False)]
     
-    # Ajouter les réponses aux résultats
-    filtered_results["qa_info"] = filtered_results["id"].apply(
-        lambda prod_id: [prod["qa_info"] for prod in products_data if prod["id"] == prod_id][0]
-    )
-
-    return filtered_results.sort_values(by="score", ascending=False).head(20)
+    return results_df.sort_values(by="score", ascending=False).head(20)
 
 # Interface Gradio
 app = gr.Interface(