Update src/Algorithms/vector_search.py

src/Algorithms/vector_search.py

@@ -1,72 +1,95 @@
 """
-MODULE VECTOR SEARCH - HYBRID ENGINE
-====================================
-Indexe le graphe pour permettre la recherche sémantique et par type.
+MODULE: VECTOR SEARCH ENGINE (FAISS + SENTENCE TRANSFORMERS)
+============================================================
+Responsabilité : Transformer le texte en vecteurs et trouver les points d'entrée sémantiques.
 """
-import pandas as pd
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
+import faiss
 import numpy as np
+from sentence_transformers import SentenceTransformer
+import pickle
+import os
 
-class GraphVectorEngine:
-    def __init__(self):
-        self.vectorizer = TfidfVectorizer(stop_words='english')
-        self.vectors = None
-        self.node_ids = []
-        self.node_data = []
+class SemanticIndex:
+    def __init__(self, model_name='all-MiniLM-L6-v2'):
+        # Modèle léger et rapide, parfait pour CPU
+        self.model = SentenceTransformer(model_name)
+        self.index = None
+        self.uris = [] # Stocke les IDs correspondants aux vecteurs
+        self.metadatas = []
         self.is_ready = False
 
-    def index_graph(self, G):
-        """Transforme chaque nœud du graphe en document textuel searchable"""
-        self.node_ids = []
-        self.node_data = []
+    def build_index(self, rdf_graph):
+        """
+        Parcourt le graphe RDF pour vectoriser chaque entité.
+        On crée une 'soupe' de texte : (Type + Label + Propriétés Clés)
+        """
+        print("⏳ [VECTOR] Embedding generation started...")
         corpus = []
+        self.uris = []
+        self.metadatas = []
 
-        for node_id, data in G.nodes(data=True):
-            # On crée une "soupe" de texte avec toutes les valeurs du nœud
-            # Ex: "CLI-2026-001 Jean Dupont Dakar Responsable Commercial"
-            text_content = f"{node_id} "
-            text_content += " ".join([str(v) for k, v in data.items() 
-                                    if k not in ['color', 'size', 'shape', 'x', 'y', 'title']])
+        # On itère sur tous les sujets du graphe RDF qui ont un label
+        # Note: On suppose que rdf_manager a déjà peuplé le graphe
+        # Ici on simplifie : on s'attend à recevoir une liste de dicts ou on itère le graph
+        pass 
+
+    def build_from_networkx(self, G):
+        """
+        Construit l'index depuis le graphe NetworkX (plus simple car déjà structuré)
+        avant la conversion RDF.
+        """
+        corpus = []
+        self.uris = []
+        
+        for node, data in G.nodes(data=True):
+            # Construction de la "Signature Sémantique" du nœud
+            # Ex: "Garant Jean Dupont Ingénieur Informatique Dakar"
+            text_parts = [
+                str(data.get('group', '')),
+                str(data.get('label', '')),
+                str(data.get('Profession', '')),
+                str(data.get('Ville', '')),
+                str(data.get('Secteur_Activite', '')),
+                str(data.get('Commentaires_Notes', ''))
+            ]
+            # Nettoyage
+            text = " ".join([t for t in text_parts if t and t != 'nan']).lower()
             
-            self.node_ids.append(node_id)
-            self.node_data.append(data)
-            corpus.append(text_content.lower())
+            corpus.append(text)
+            self.uris.append(node)
+            self.metadatas.append(f"{data.get('group')} - {data.get('label')}")
+
+        if not corpus:
+            return "⚠️ Graphe vide."
 
-        if corpus:
-            self.vectors = self.vectorizer.fit_transform(corpus)
-            self.is_ready = True
-            return f"✅ Indexation vectorielle terminée : {len(self.node_ids)} entités."
-        return "⚠️ Graphe vide, indexation impossible."
+        # Vectorisation (Batch)
+        embeddings = self.model.encode(corpus, show_progress_bar=True)
+        
+        # Création Index FAISS
+        dimension = embeddings.shape[1]
+        self.index = faiss.IndexFlatL2(dimension)
+        self.index.add(np.array(embeddings).astype('float32'))
+        
+        self.is_ready = True
+        return f"✅ Index FAISS construit : {len(self.uris)} entités vectorisées."
 
-    def search_semantic(self, query, top_k=5, threshold=0.1):
-        """Recherche vectorielle (similitude de texte)"""
+    def search(self, query, top_k=5):
+        """Retourne les URIs les plus proches de la requête"""
         if not self.is_ready:
             return []
 
-        query_vec = self.vectorizer.transform([query.lower()])
-        cosine_sim = cosine_similarity(query_vec, self.vectors).flatten()
+        # Vectoriser la question
+        query_vec = self.model.encode([query.lower()]).astype('float32')
         
-        # Récupérer les indices des meilleurs scores
-        related_docs_indices = cosine_sim.argsort()[:-top_k-1:-1]
+        # Recherche FAISS
+        distances, indices = self.index.search(query_vec, top_k)
         
         results = []
-        for idx in related_docs_indices:
-            score = cosine_sim[idx]
-            if score > threshold:
+        for i, idx in enumerate(indices[0]):
+            if idx < len(self.uris):
                 results.append({
-                    "id": self.node_ids[idx],
-                    "score": round(score, 2),
-                    "type": self.node_data[idx].get('group', 'Inconnu'),
-                    "label": self.node_data[idx].get('label', self.node_ids[idx])
+                    "uri": self.uris[idx],
+                    "meta": self.metadatas[idx],
+                    "score": float(1 / (1 + distances[0][i])) # Conversion distance -> score sim
                 })
-        return results
-
-    def get_all_by_type(self, entity_type):
-        """Retourne tous les nœuds d'un type précis (ex: 'Garant')"""
-        results = []
-        for i, data in enumerate(self.node_data):
-            # Vérification souple (ex: 'Garant' matche 'Garant_KYC')
-            if entity_type.lower() in str(data.get('group', '')).lower():
-                results.append(self.node_ids[i])
         return results