LLM : Textstat et LangChain contre les réponses verbeuses

Les grands modèles de langage (LLM) sont souvent critiqués pour leur tendance à produire des réponses excessivement verbeuses. Cette caractéristique, bien qu'elle soit le résultat d'une optimisation pour rendre les modèles aussi utiles et conversationnels que possible, peut entraîner des problèmes. En effet, plus une réponse est longue, plus elle risque de s'écarter des faits établis et de générer des "hallucinations".

Pour contrer ce phénomène, il est crucial de mettre en place des garde-fous robustes. L'un des outils proposés pour cela est la bibliothèque Python Textstat, qui permet de mesurer la lisibilité des textes générés par les LLM. Textstat utilise des indices comme l'indice de lisibilité automatisé (ARI) pour évaluer le niveau scolaire requis pour comprendre un texte. Si ce niveau dépasse un certain seuil, par exemple un score ARI de 10.0, une boucle de relance peut être déclenchée pour simplifier la réponse.

Définir un Budget de Complexité avec Textstat

La bibliothèque Textstat peut être utilisée pour calculer des scores tels que l'indice de lisibilité automatisé (ARI), qui estime le niveau scolaire nécessaire pour comprendre un texte, comme une réponse de modèle. Si ce métrique de complexité dépasse un budget ou un seuil — tel que 10.0, équivalent à un niveau de lecture de 10e année — une boucle de relance peut être automatiquement déclenchée pour exiger une réponse plus concise et simple. Cette stratégie non seulement élimine le langage fleuri, mais peut également aider à réduire les risques d'hallucination, car le modèle adhère plus strictement aux faits fondamentaux en conséquence.

Mise en Œuvre du Pipeline LangChain

Pour mettre en œuvre cette stratégie, un pipeline utilisant LangChain peut être configuré dans un environnement Google Colab. Vous aurez besoin d'un jeton API Hugging Face, obtenable gratuitement sur https://huggingface.co/settings/tokens. Créez un nouveau "secret" nommé HF_TOKEN dans le menu de gauche de Colab en cliquant sur l'icône "Secrets" (qui ressemble à une clé). Collez le jeton API généré dans le champ "Value", et vous êtes prêt !

Pour commencer, installez les bibliothèques nécessaires :

!pip install textstat langchain_huggingface langchain_community

Le code suivant est spécifique à Google Colab, et vous devrez peut-être l'ajuster en fonction de votre environnement. Il se concentre sur la récupération du jeton API stocké :

from google.colab import userdata

# Obtenir le jeton API Hugging Face enregistré dans les Secrets de votre session Colab
HF_TOKEN = userdata.get('HF_TOKEN')

# Vérifier la récupération du jeton
if not HF_TOKEN:
    print("WARNING: Le jeton 'HF_TOKEN' n'a pas été trouvé. Cela peut causer des erreurs.")
print("Jeton Hugging Face chargé avec succès.")

Dans le code suivant, nous effectuons plusieurs actions. Tout d'abord, il configure des composants pour la génération de texte local via un modèle pré-entraîné de Hugging Face — spécifiquement distilgpt2. Ensuite, le modèle est intégré dans un pipeline LangChain.

from langchain_core.prompts import PromptTemplate
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from langchain_community.llms import HuggingFacePipeline

# Initialisation d'un LLM compatible, local et gratuit pour la génération de texte
model_id = "distilgpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)

# Création d'un pipeline de génération de texte
pipe = pipeline(
    "text-generation",
    tokenizer=tokenizer,
    max_new_tokens=100,
    device=0  # Utiliser le GPU si disponible, sinon il passera par défaut au CPU
)

# Envelopper le pipeline dans HuggingFacePipeline
llm = HuggingFacePipeline(pipeline=pipe)

Notre mécanisme principal pour mesurer et gérer la verbosité est ensuite mis en œuvre. La fonction suivante génère un résumé du texte qui lui est passé (présumé être une réponse d'un LLM) et essaie de s'assurer que le résumé ne dépasse pas un niveau de complexité seuil. Notez qu'en utilisant un modèle de prompt approprié, des modèles de génération comme distilgpt2 peuvent être utilisés pour obtenir des résumés de texte, bien que la qualité de ces résumés puisse ne pas correspondre à celle de modèles plus lourds axés sur le résumé. Nous avons choisi ce modèle en raison de sa fiabilité pour une exécution locale dans un environnement contraint.

def safe_summarize(text_input, complexity_budget=10.0):
    print("\n--- Début du processus de résumé ---")
    print(f"Longueur du texte d'entrée : {len(text_input)} caractères")
    print(f"Budget de complexité cible (score ARI) : {complexity_budget}")

    # Étape 1 : Génération du résumé initial
    print("Génération d'un résumé complet initial...")
    base_prompt = PromptTemplate.from_template(
        "Fournissez un résumé complet du texte suivant : {text}"
    )
    chain = base_prompt | llm
    summary = chain.invoke({"text": text_input})
    print("Résumé initial généré :")
    print("-------------------------")
    print(summary)
    print("-------------------------")

    # Étape 2 : Mesurer la lisibilité
    ari_score = textstat.automated_readability_index(summary)
    print(f"Score ARI initial : {ari_score:.2f}")

    # Étape 3 : Appliquer le budget de complexité
    if ari_score > complexity_budget:
        print("Budget dépassé ! Le résumé initial est trop complexe.")
        print("Déclenchement du garde-fou de simplification...")
        simplification_prompt = PromptTemplate.from_template(
            "Le texte suivant est trop verbeux. Réécrivez-le de manière concise "
            "en utilisant un vocabulaire simple, en éliminant le langage fleuri :\n\n{text}"
        )
        simplify_chain = simplification_prompt | llm
        simplified_summary = simplify_chain.invoke({"text": summary})
        new_ari = textstat.automated_readability_index(simplified_summary)
        print("Résumé simplifié généré :")
        print("-------------------------")
        print(simplified_summary)
        print("-------------------------")
        print(f"Nouveau score ARI : {new_ari:.2f}")
        summary = simplified_summary
    else:
        print("Le résumé initial est dans le budget de complexité. Aucune simplification nécessaire.")

    print("--- Processus de résumé terminé ---")

Notez également dans le code ci-dessus que les scores ARI sont calculés pour estimer la complexité du texte.

Exemple de texte et test de la fonction

La dernière partie de l'exemple de code teste la fonction définie précédemment, en passant un texte d'exemple et un budget de complexité de 10.0, et en affichant les résultats finaux.

• Fournir un texte d'exemple très verbeux et complexe :

sample_text = """
Les permutations inextricablement liées des tableaux de calcul cognitif dans le
domaine des Grands Modèles de Langage entraînent souvent une cascade de structures
lexicales inutilement labyrinthiques. Cette propension à la circonlocution, bien que
semblant indiquer une érudition profonde, obfusque fréquemment la charge sémantique
fondamentale, rendant ainsi le discours généré significativement moins accessible
au citoyen lambda.
"""

- Appeler la fonction :

```python
print("Exécution du pipeline de résumé...\n")
final_output = safe_summarize(sample_text, complexity_budget=10.0)

• Afficher le résultat final :

print("\n--- Résumé final avec garde-fou ---")
print(final_output)

Les messages imprimés résultants peuvent être assez longs, mais vous constaterez une légère diminution du score ARI après avoir appelé le modèle pré-entraîné pour le résumé. Ne vous attendez pas à des résultats miraculeux, cependant : le modèle choisi, bien que léger, n'est pas excellent pour résumer du texte, donc la réduction du score ARI est plutôt modeste. Vous pouvez essayer d'utiliser d'autres modèles comme google/flan-t5-small pour voir comment ils se comportent pour le résumé de texte, mais attention — ces modèles seront plus lourds et plus difficiles à exécuter.

Cet article montre comment mettre en œuvre une infrastructure pour mesurer et contrôler les réponses trop verbeuses des LLM en appelant un modèle auxiliaire pour les résumer avant d'approuver leur niveau de complexité. Les hallucinations sont un sous-produit de la haute verbosité dans de nombreux scénarios. Bien que l'implémentation présentée ici se concentre sur l'évaluation de la verbosité, il existe des vérifications spécifiques qui peuvent également être utilisées pour mesurer les hallucinations — telles que les vérifications de cohérence sémantique, les encodeurs croisés d'inférence en langage naturel (NLI), et les solutions LLM en tant que juge.

Iván Palomares Carrascosa est un leader, écrivain, conférencier et conseiller en IA, apprentissage automatique, apprentissage profond et LLMs. Il forme et guide d'autres personnes dans l'utilisation de l'IA dans le monde réel.