Skip to content
TheChatArchiveThe Chat Archive
Kimikimi-k2-0711-preview· Moonshot AIHugging Face LMArena Human Preference 140K

salut jai une variable de langa=chain qui s'appelle doc et qui contient les chunks ( à…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-5-haiku-20241022’s answer.
  1. User

    salut jai une variable de langa=chain qui s'appelle doc et qui contient les chunks ( à partir de ce code for chunking_method in chunking_methods: doc=load_json_splitter(json_path, chunking_method) # print(len(doc)) nb_chunks_list.append(len(doc))) je veux que tu m'aides à preparer un code qui permet de Mesurer les chunks a quel point ils sont proches les uns des autres ? ​

    La difference impacte elle reponse , la performance ?​

  2. Kimi Assistant

    Salut ! Très bonne question — mesurer la similarité entre les chunks est une étape clé pour évaluer la cohérence, la redondance, et potentiellement l’impact sur la qualité des réponses dans un système RAG (Retrieval-Augmented Generation).


    ✅ Objectif

    Tu veux mesurer à quel point les chunks sont proches les uns des autres, et voir si cette proximité (ou redondance) impacte la performance (ex. : pertinence des réponses, hallucinations, etc.).


    🔍 Étapes pour mesurer la similarité entre chunks

    1. Charger les chunks

    Tu as déjà :

    for chunking_method in chunking_methods:
        doc = load_json_splitter(json_path, chunking_method)
    

    On suppose que doc est une liste de Document (LangChain), donc on accède au texte via doc[i].page_content.


    2. Vectoriser les chunks

    On utilise un modèle de sentence embeddings (ex. sentence-transformers/all-MiniLM-L6-v2) :

    from sentence_transformers import SentenceTransformer
    import numpy as np
    from sklearn.metrics.pairwise import cosine_similarity
    
    model = SentenceTransformer("all-MiniLM-L6-v2")
    
    def compute_chunk_similarity(docs):
        texts = [d.page_content for d in docs]
        embeddings = model.encode(texts)
        similarity_matrix = cosine_similarity(embeddings)
        return similarity_matrix
    

    3. Calculer des métriques de similarité

    On peut calculer :

    • Similarité moyenne entre chunks
    • % de paires très similaires (> 0.9)
    • Matrice de similarité
    def analyze_similarity(similarity_matrix):
        # Masquer la diagonale (similarité d’un chunk avec lui-même)
        np.fill_diagonal(similarity_matrix, np.nan)
        mean_sim = np.nanmean(similarity_matrix)
        high_sim_pairs = np.sum(similarity_matrix > 0.9) / 2  # diviser par 2 car symétrique
        total_pairs = (similarity_matrix.shape[0] * (similarity_matrix.shape[0] - 1)) / 2
        high_sim_ratio = high_sim_pairs / total_pairs
        return {
            "mean_similarity": mean_sim,
            "high_similarity_ratio": high_sim_ratio
        }
    

    4. Boucler sur les méthodes de chunking

    results = {}
    
    for chunking_method in chunking_methods:
        doc = load_json_splitter(json_path, chunking_method)
        sim_matrix = compute_chunk_similarity(doc)
        stats = analyze_similarity(sim_matrix)
        results[chunking_method] = {
            "nb_chunks": len(doc),
            **stats
        }
    
    # Affichage
    import pandas as pd
    df = pd.DataFrame.from_dict(results, orient='index')
    print(df)
    

    📊 Interprétation

    chunking_methodnb_chunksmean_similarityhigh_similarity_ratio
    recursive1200.720.15
    semantic850.550.05
    • mean_similarity élevée → risque de redondance
    • high_similarity_ratio élevé → beaucoup de chunks se ressemblent → peut fausser le retrieval (même info retrouvée plusieurs fois)

    🧪 Est-ce que ça impacte la performance ?

    Oui, potentiellement :

    • Redondance élevée → le système peut répéter les mêmes infos dans la réponse
    • Chunks trop similaires → moins de diversité dans le contexte → réponses moins complètes
    • Chunks trop différents → risque de perte de cohérence

    ✅ Prochaines étapes

    1. Corréler ces scores avec une évaluation manuelle ou LLM-as-a-judge sur un jeu de questions
    2. Visualiser la matrice de similarité (heatmap)
    3. Ajuster la méthode de chunking selon les résultats

    Si tu veux, je peux t’aider à :

    • Visualiser la matrice de similarité
    • Ajouter une évaluation automatique des réponses
    • Comparer plusieurs méthodes de chunking avec un benchmark

    Tu veux aller plus loin ?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.