Update app.py

app.py

@@ -6,182 +6,112 @@ import torch
 import pandas as pd
 import time
 import marqo
+import requests
 from scipy.sparse import csr_matrix
 from transformers import AutoModel, AutoProcessor
 from sklearn.feature_extraction.text import TfidfVectorizer
 
-# Vérifier si CUDA est disponible (GPU)
+# Vérifier si CUDA est disponible
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🔹 Utilisation du périphérique : {device}")
 
+# Lancer Marqo si nécessaire
+os.system("docker run -d -p 8882:8882 marqoai/marqo")
+
+# Vérifier que Marqo est bien lancé
+def wait_for_marqo(timeout=30):
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get("http://localhost:8882")
+            if response.status_code == 200:
+                print("✅ Marqo est prêt !")
+                return True
+        except requests.exceptions.ConnectionError:
+            print("⏳ En attente du démarrage de Marqo...")
+            time.sleep(3)
+    print("⛔ Marqo ne répond pas après 30 secondes. Vérifiez le démarrage.")
+    return False
+
+if not wait_for_marqo():
+    exit(1)
+
+# Connexion à Marqo avec gestion des erreurs
+MAX_RETRIES = 5
+for attempt in range(MAX_RETRIES):
+    try:
+        mq = marqo.Client(url="http://localhost:8882")
+        print("✅ Connexion à Marqo réussie !")
+        break
+    except marqo.errors.BackendCommunicationError:
+        print(f"⚠️ Erreur de connexion à Marqo (tentative {attempt + 1}/{MAX_RETRIES})")
+        time.sleep(5)
+else:
+    print("⛔ Impossible de se connecter à Marqo après plusieurs tentatives.")
+    exit(1)
+
 # Définition des fichiers JSON
 PRODUCTS_FILE = "products.json"
 QA_FILE = "qa_sequences_output.json"
 
-# Chargement sécurisé du modèle Marqo
-MAX_RETRIES = 3
-model_name = "Marqo/marqo-ecommerce-embeddings-L"
+# Fonction pour charger les fichiers JSON de manière sécurisée
+def safe_load_json(file_path):
+    if not os.path.exists(file_path):
+        print(f"⛔ Fichier introuvable : {file_path}")
+        return []
 
-for attempt in range(MAX_RETRIES):
     try:
-        print(f"🔄 Chargement du modèle Marqo... (Tentative {attempt + 1}/{MAX_RETRIES})")
-        model = AutoModel.from_pretrained(model_name, trust_remote_code=True).to(device)
-        processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
-        print("✅ Modèle chargé avec succès !")
-        break
-    except Exception as e:
-        print(f"❌ Erreur de chargement : {e}")
-        if attempt < MAX_RETRIES - 1:
-            print("🔁 Nouvelle tentative dans 5 secondes...")
-            time.sleep(5)
-        else:
-            print("⛔ Échec final du chargement du modèle.")
-            model, processor = None, None
-
-# Fonction pour charger les fichiers JSON
-def load_data():
-    products_data, qa_data = [], []
-
-    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}")
-
-    if os.path.exists(QA_FILE):
-        with open(QA_FILE, "r", encoding="utf-8") as f:
-            qa_data = json.load(f)
-    else:
-        print(f"⛔ Fichier introuvable : {QA_FILE}")
-
-    return products_data, qa_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"
+        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 json.JSONDecodeError:
+        print(f"⚠️ Erreur de décodage JSON dans {file_path}")
+        return []
 
-# Supprimer et recréer l'index
-try:
+products_data = safe_load_json(PRODUCTS_FILE)
+qa_data = safe_load_json(QA_FILE)
+
+# Création de l'index Marqo avec la bonne configuration
+INDEX_NAME = "ecommerce_products"
+if INDEX_NAME in [index["index_name"] for index in mq.get_indexes()["results"]]:
     mq.delete_index(INDEX_NAME)
-except:
-    pass
 
-# Création de l'index
-mq.create_index(INDEX_NAME)
+mq.create_index(INDEX_NAME, model="open_clip/ViT-B-32/laion2B-b79K", normalize_embeddings=True)
 print("✅ Index Marqo créé avec succès !")
 
 # Ajouter les produits à Marqo
-documents = []
-for product in products_data:
-    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", []),
-        "_model": "open_clip/ViT-B-32/laion2B-b79K",  # Spécifier le modèle ici
+documents = [
+    {
+        "id": product.get("id", ""),
+        "title": product.get("title", ""),
+        "description": product.get("description", ""),
+        "price": product.get("price", 0),
+        "availability": product.get("availability", ""),
+        "category": product.get("category", ""),
     }
-    documents.append(doc)
+    for product in products_data
+]
 
 mq.index(INDEX_NAME).add_documents(documents, tensor_fields=["title", "description"])
 print("✅ Produits indexés dans Marqo avec succès !")
 
-# Prétraitement du texte
-def preprocess(text: str) -> str:
-    text = text.lower()
-    text = re.sub(r'\s+', ' ', text)
-    text = re.sub(r'[^\w\s]', '', text)
-    return text.strip()
-
-# TF-IDF Vectorizer
-vectorizer = TfidfVectorizer(stop_words="english")
-tfidf_matrix = vectorizer.fit_transform([prod["title"] + " " + prod["description"] for prod in products_data])
-
-# 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]))
-    tfidf_scores = (tfidf_matrix * query_vector_sparse.T).toarray().flatten()
-
-    # 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":
-        results_df = results_df[results_df["category"].str.contains(category, case=False, na=False)]
-    
-    return results_df.sort_values(by="score", ascending=False).head(20)
-
 # Interface Gradio
+def search_products(query, category, min_price, max_price):
+    query = query.strip()
+    if not query:
+        return "❌ Veuillez entrer un terme de recherche valide."
+
+    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")
+
+    marqo_results = mq.index(INDEX_NAME).search(query, searchable_attributes=["title", "description"], limit=20)
+    results_df = pd.DataFrame(marqo_results["hits"])
+    return results_df
+
 app = gr.Interface(
     fn=search_products,
-    inputs=[
-        gr.Textbox(label="Rechercher un produit"), 
-        gr.Textbox(label="Catégorie"), 
-        gr.Number(label="Prix min"), 
-        gr.Number(label="Prix max")
-    ],
-    outputs=[
-        gr.Dataframe(headers=["ID", "Titre", "Description", "Prix", "Disponibilité", "Questions/Réponses"], 
-                     datatype=["str", "str", "str", "number", "str", "json"])
-    ]
+    inputs=[gr.Textbox(label="Rechercher un produit"), gr.Textbox(label="Catégorie"), gr.Number(label="Prix min"), gr.Number(label="Prix max")],
+    outputs=gr.Dataframe(),
 )
 
 app.launch()