embedding model Updated

config.py

@@ -5,6 +5,9 @@ from pinecone import Pinecone, ServerlessSpec, Index
 from langsmith import Client
 from langchain_mistralai.chat_models import ChatMistralAI
 from neo4j import GraphDatabase
+from sentence_transformers import SentenceTransformer
+from pinecone_text.sparse import BM25Encoder
+from langchain.embeddings import HuggingFaceEmbeddings
 
 # Charger les variables d'environnement
 load_dotenv()
@@ -50,6 +53,11 @@ llm = ChatMistralAI(
     verbose=True
 )
 
+# Initialiser les modèles et encodeurs
+model = SentenceTransformer("intfloat/multilingual-e5-large")
+sparse_encoder = BM25Encoder().default()
+embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
+
 # Vérifier si les index existent
 existing_indexes = pc.list_indexes()
 all_names = [idx["name"] for idx in existing_indexes]

neo4j_utils.py

@@ -1,6 +1,3 @@
-from sentence_transformers import SentenceTransformer
-from pinecone_text.sparse import BM25Encoder
-from langchain.embeddings import HuggingFaceEmbeddings
 from langchain.schema import HumanMessage 
 import json
 import streamlit as st
@@ -13,13 +10,6 @@ import logging
 logging.basicConfig(level=logging.INFO)  
 logger = logging.getLogger(__name__)
 
-
-# Initialiser les modèles et encodeurs
-model = SentenceTransformer("intfloat/multilingual-e5-large")
-sparse_encoder = BM25Encoder().default()
-embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
-
-
 def extract_cypher_query(llm_output):
     """
     Extrait la requête Cypher valide de la sortie du LLM.

pinecone_utilsA.py

@@ -1,5 +1,6 @@
 from sentence_transformers import SentenceTransformer
 from config import dense_index as indexA
+from config import *
 import zlib
 import base64
 
@@ -36,7 +37,6 @@ def get_existing_vectors(index):
 
 def index_pdf(texts):
     """Indexe les textes dans l'index dense en évitant les doublons."""
-    model = SentenceTransformer('intfloat/multilingual-e5-large')
     vectors = model.encode(texts)
     
     # Récupérer les textes déjà indexés
@@ -73,7 +73,6 @@ def index_pdf(texts):
 
 def retrieve_documents(query, k, similarity_threshold):
     """Récupère les documents pertinents en fonction de la requête."""
-    model = SentenceTransformer('intfloat/multilingual-e5-large')
     query_vector = model.encode([query]).tolist()[0]
     results = indexA.query(
         vector=query_vector,
@@ -82,13 +81,27 @@ def retrieve_documents(query, k, similarity_threshold):
         )
 
     relevant_docs = []
+    total_words = 0
+    total_tokens = 0
     for match in results.get("matches", []):
         if "metadata" in match and "compressed_text" in match["metadata"]:
             score = match.get("score", 0)  # Score de similarité
             if score >= similarity_threshold:  # Filtrer par seuil
                 compressed_text = match["metadata"]["compressed_text"]
-                relevant_docs.append(decompress_text(compressed_text))
+                text = decompress_text(compressed_text)
+                relevant_docs.append(text)
+
+                # Calcul du nombre de mots et de tokens
+                total_words += len(text.split())  # Nombre de mots (séparés par des espaces)
+                total_tokens += len(model.tokenizer.encode(text))  # Nombre de tokens
+
         else:
             print(f"Skipping match due to missing metadata or compressed_text: {match}")
-    print(f"Nombre de documents récupérés : {len(relevant_docs)}")
+    num_docs = len(relevant_docs)
+    avg_words_per_doc = total_words / num_docs if num_docs > 0 else 0
+    avg_tokens_per_doc = total_tokens / num_docs if num_docs > 0 else 0
+
+    print(f"Nombre de documents récupérés : {num_docs}")
+    print(f"Moyenne de mots par document : {avg_words_per_doc:.2f}")
+    print(f"Moyenne de tokens par document : {avg_tokens_per_doc:.2f}")
     return relevant_docs

pinecone_utilsB.py

@@ -1,8 +1,6 @@
-from sentence_transformers import SentenceTransformer
-from pinecone_text.sparse import BM25Encoder
-from langchain.embeddings import HuggingFaceEmbeddings
 import streamlit as st
 from config import sparse_index as indexB
+from config import *
 import nltk
 import zlib
 import base64
@@ -12,11 +10,6 @@ import uuid
 
 nltk.download('punkt_tab')
 
-# Initialiser les modèles et encodeurs
-model = SentenceTransformer("intfloat/multilingual-e5-large")
-sparse_encoder = BM25Encoder().default()
-embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
-
 # Initialiser l'état de session pour Streamlit
 if "bm25_corpus" not in st.session_state:
     st.session_state.bm25_corpus = []
@@ -133,6 +126,9 @@ def hybrid_search(query, alpha, k, similarity_threshold):
         
         # Récupérer les documents pertinents
         relevant_docs = []
+        total_words = 0
+        total_tokens = 0
+
         for match in results.get("matches", []):
             if "metadata" in match and "compressed_text" in match["metadata"]:
                 score = match.get("score", 0)  # Score de similarité
@@ -141,17 +137,32 @@ def hybrid_search(query, alpha, k, similarity_threshold):
                     sparse_values_json = match["metadata"].get("sparse_values")
 
                     # Désérialiser les valeurs sparse si elles existent
-                    if sparse_values_json:
-                        sparse_values = json.loads(sparse_values_json)
+                    sparse_values = json.loads(sparse_values_json) if sparse_values_json else None
 
+                    # Décompression du texte
+                    text = decompress_text(compressed_text)
                     relevant_docs.append({
-                        "text": decompress_text(compressed_text),
+                        "text": text,
                         "sparse_values": sparse_values,
                         "score": score
                     })
+
+                    # Calcul du nombre de mots et de tokens
+                    total_words += len(text.split())  # Nombre de mots (séparés par des espaces)
+                    total_tokens += len(model.tokenizer.encode(text))  # Nombre de tokens
+
             else:
                 print(f"Skipping match due to missing metadata or compressed_text: {match}")
-        #print(f"Nombre de documents récupérés : {len(relevant_docs)}")
+
+        # Calcul des moyennes
+        num_docs = len(relevant_docs)
+        avg_words_per_doc = total_words / num_docs if num_docs > 0 else 0
+        avg_tokens_per_doc = total_tokens / num_docs if num_docs > 0 else 0
+
+        print(f"Nombre de documents récupérés : {num_docs}")
+        print(f"Moyenne de mots par document : {avg_words_per_doc:.2f}")
+        print(f"Moyenne de tokens par document : {avg_tokens_per_doc:.2f}")
+
         return relevant_docs
 
     except Exception as e:
@@ -159,6 +170,7 @@ def hybrid_search(query, alpha, k, similarity_threshold):
         return []
 
 
+
 def compress_text(text):
         """Compresse un texte en base64."""
         compressed = zlib.compress(text.encode("utf-8"))