Correctness LLM evaluation

config.py

@@ -33,6 +33,7 @@ client = Client(
     api_url=langsmith_endpoint,
     api_key=langsmith_api_key,
 )
+dataset_id = os.getenv("DATASET_UUID")
 
 # Initialize Neo4j connection
 neo4j_uri = os.getenv("NEO4J_URI")

evaluations/correctness.py

@@ -0,0 +1,60 @@
+from typing_extensions import Annotated, TypedDict
+from langchain.chat_models import ChatOpenAI
+from config import client, llm
+from config import dataset_id
+
+# Define the output schema for grading
+class CorrectnessGrade(TypedDict):
+    explanation: Annotated[str, ..., "Expliquez votre raisonnement pour la note."]
+    score: Annotated[float, ..., "Un score de 0 à 10 basé sur la justesse de la réponse"]
+
+# Grading prompt with expert evaluation criteria
+correctness_instructions = """Vous êtes un expert en intelligence artificielle chargé d'évaluer la pertinence d'une réponse générée par un système RAG.
+
+**Instructions** :
+- Vous recevrez une QUESTION, une RÉPONSE DE RÉFÉRENCE (vérité terrain) et une RÉPONSE GÉNÉRÉE.
+- Évaluez uniquement la précision factuelle de la réponse générée par rapport à la référence.
+- Une réponse peut contenir plus d'informations que la référence, tant qu'elles sont exactes.
+- Si la réponse générée contient des erreurs ou des informations contradictoires, pénalisez-la.
+
+**Notation (score sur 10)** :
+- **0 (Très insuffisant)** : Réponse hors sujet ou contenant des erreurs majeures.
+- **2.5 (Insuffisant)** : Réponse partiellement correcte mais incomplète ou floue.
+- **5 (Correct)** : Réponse pertinente mais manquant de clarté ou de détails.
+- **7.5 (Bon)** : Réponse pertinente, claire et complète avec une légère amélioration possible.
+- **10 (Très bon)** : Réponse exacte, détaillée et bien structurée.
+
+**Expliquez votre notation étape par étape.**"""
+
+def get_reference_answer(question: str) -> str:
+    """Retrieve the reference answer from a LangSmith dataset."""
+    
+    # Récupérer les exemples stockés dans le dataset
+    dataset = client.list_examples(dataset_id)
+
+    # Chercher la correspondance exacte
+    for example in dataset:
+        if example.inputs.get("question") == question:
+            return example.outputs.get("answer")  # Retourne la réponse de référence
+    
+    return None  # Si aucune correspondance n'est trouvée
+
+def correctness(inputs: dict, outputs: dict) -> float:
+    """Evaluates the correctness of a RAG-generated answer and returns a score (0-10)."""
+    question = inputs["question"]
+    reference_answer = get_reference_answer(question)
+    
+    if not reference_answer:
+        raise ValueError(f"No reference answer found for question: {question}")
+
+    answers = f"""\nQUESTION: {question}
+    RÉPONSE DE RÉFÉRENCE: {reference_answer}
+    RÉPONSE GÉNÉRÉE: {outputs['answer']}"""
+
+    # Invoke the LLM for grading
+    grade = llm.invoke([
+        {"role": "system", "content": correctness_instructions}, 
+        {"role": "user", "content": answers}
+    ])
+    
+    return grade["score"]

graph_agentC.py

@@ -6,6 +6,7 @@ from neo4j_utils import unified_search
 from typing import TypedDict, Sequence, List, Dict, Optional, Annotated
 from config import llm
 import re
+from evaluations.correctness import correctness
 
 class GraphState(TypedDict):
     messages: Annotated[Sequence[BaseMessage], add_messages]
@@ -13,6 +14,8 @@ class GraphState(TypedDict):
     relevant_docs: List[Dict[str, Optional[Dict[str, float]]]]  # Résultats de la recherche hybride
     neo4j_results: list  # Résultats de la recherche Neo4j
     response: str
+    score: Optional[float] 
+    evaluation_explanation: Optional[str]
     k: int 
     alpha: float
     similarity_threshold: float
@@ -79,6 +82,22 @@ def generate_response(state: GraphState) -> dict:
     
     return {"response": response_cleaned}
 
+
+def evaluate_response(state: GraphState) -> dict:
+    """Évalue la réponse générée en comparant avec la vérité terrain (LangSmith)."""
+    
+    inputs = {"question": state["query"]}
+    outputs = {"answer": state["response"]}
+    
+    try:
+        score = correctness(inputs, outputs)
+        explanation = f"La réponse a obtenu un score de {score}/10. Voici l'explication de l'évaluation..."
+    except Exception as e:
+        score = 0
+        explanation = f"Erreur lors de l'évaluation : {str(e)}"
+    
+    return {"score": score, "evaluation_explanation": explanation}
+
     
 
 def post_process_response(state: GraphState) -> dict:
@@ -88,13 +107,20 @@ def post_process_response(state: GraphState) -> dict:
     # Vérifier si la réponse est pertinente
     if not response or response.lower() in ["je ne sais pas", "i don't know"]:
         response = "Désolé, je n'ai pas trouvé d'informations pertinentes pour votre question."
-    return {"response": response}
+
+    evaluation = evaluate_response(state)
+    return {
+        "response": response,
+        "score": evaluation["score"],  # Ajout du score
+        "evaluation_explanation": evaluation["evaluation_explanation"]  # Explication
+    }
 
 
 # Construction du graphe
 graph_builder = StateGraph(GraphState)
 
 # Ajouter les nœuds
+graph_builder.add_node("evaluate", evaluate_response)
 graph_builder.add_node("retrieve", retrieve_unified) 
 graph_builder.add_node("generate", generate_response)
 graph_builder.add_node("post_process", post_process_response)
@@ -102,7 +128,8 @@ graph_builder.add_node("post_process", post_process_response)
 # Définir les transitions
 graph_builder.set_entry_point("retrieve")
 graph_builder.add_edge("retrieve", "generate")
-graph_builder.add_edge("generate", "post_process")
+graph_builder.add_edge("generate", "evaluate")
+graph_builder.add_edge("evaluate", "post_process")
 graph_builder.add_edge("post_process", END)
 
 # Compiler le graphe

pdf_processing.py

@@ -1,8 +1,9 @@
-import PyPDF2
-import re
-import os
+from transformers import AutoTokenizer
 from langchain.text_splitter import CharacterTextSplitter
 import pdfplumber
+from config import *
+import re
+import os
 
 def get_existing_pdf(filename="La Confession muette.pdf"):
     """Retrieve the PDF file if it exists."""
@@ -20,12 +21,36 @@ def load_and_preprocess_pdf(pdf_path):
     text = re.sub(r'\*+ebook converter demo watermarks\*+', '', text, flags=re.IGNORECASE)
     return text
 
+def token_length(text):
+    """Calcule la longueur en tokens en utilisant SentenceTransformer."""
+    return len(model.tokenize(text)) 
+
 def split_text(text):
-    """Split text into chunks."""
+    """Split text into chunks basés sur les tokens."""
     text_splitter = CharacterTextSplitter(
         separator="\n",
-        chunk_size=2500,
-        chunk_overlap=200,
-        length_function=len
+        chunk_size=1024,  # Taille du chunk en tokens
+        chunk_overlap=200,  # Chevauchement en tokens
+        length_function=token_length  # Mesurer en tokens
     )
-    return text_splitter.split_text(text)
+    return text_splitter.split_text(text)
+
+
+
+
+
+
+
+
+
+#def split_text(text):
+#    """Split text into chunks."""
+#    text_splitter = CharacterTextSplitter(
+#        separator="\n",
+#        chunk_size=2500,
+#        chunk_overlap=200,
+#        length_function=len
+#    )
+#    return text_splitter.split_text(text)
+
+  

requirements.txt

@@ -19,7 +19,7 @@ PyPDF2>=3.0.0
 pdfplumber>=0.9.0
 
 langchain>=0.0.200
-langsmith>=0.0.10
+langsmith>=0.2.4
 langgraph>=0.2.20,<0.3
 
 python-dotenv>=1.0.0