Détecter les distorsions cognitives en 60 lignes de Python avec le NLP

Les distorsions cognitives sont des biais de pensée automatiques et irrationnels théorisés par les psychiatres Aaron Beck et David Burns. Qu’il s’agisse de la « pensée tout-ou-rien », de la « surgénéralisation » ou du « catastrophisme », ces schémas faussent notre perception de la réalité et alimentent l’anxiété.

En tant que développeurs, nous disposons aujourd'hui d’outils NLP (Natural Language Processing) suffisamment matures pour identifier ces structures directement dans du texte libre. Voyons comment concevoir un détecteur fonctionnel en une soixantaine de lignes de code.

L'approche : la classification Zero-Shot

Entraîner un modèle sur mesure pour détecter ces nuances exigerait des milliers d'exemples annotés à la main. Pour contourner cette contrainte, nous utilisons la classification zero-shot. Cette technique s’appuie sur des modèles d'inférence en langage naturel (NLI) capables d’évaluer la plausibilité d’une hypothèse sans réentraînement préalable.

Avec la bibliothèque transformers de Hugging Face et un modèle multilingue léger, l’implémentation tient dans un fichier unique.

L'implémentation en Python

from transformers import pipeline

class CognitiveDistortionDetector:
    DISTORTIONS = {
        "pensée tout-ou-rien": "La phrase reflète une vision binaire ou absolue, sans nuance.",
        "catastrophisme": "La phrase anticipe le pire scénario possible de manière disproportionnée.",
        "surgénéralisation": "La phrase tire une règle générale définitive à partir d'un événement isolé.",
        "lecture de pensée": "La phrase présume connaître les intentions négatives d'autrui sans preuve.",
        "personnalisation": "La phrase s'attribue injustement la responsabilité d'un événement externe."
    }

    def __init__(self, model_name="MoritzLaurer/mDeBERTa-v3-base-xnli-multilingual-nli-2mil7"):
        self.classifier = pipeline(
            "zero-shot-classification",
            model=model_name
        )

    def analyze(self, text: str, threshold: float = 0.5):
        candidate_labels = list(self.DISTORTIONS.keys())
        hypothesis_template = "Ce texte illustre la distorsion cognitive suivante : {}."
        
        result = self.classifier(
            text,
            candidate_labels=candidate_labels,
            hypothesis_template=hypothesis_template,
            multi_label=True
        )

        detected = []
        for label, score in zip(result["labels"], result["scores"]):
            if score >= threshold:
                detected.append({
                    "distortion": label,
                    "confidence": round(score, 3),
                    "description": self.DISTORTIONS[label]
                })

        return {
            "input_text": text,
            "has_distortion": len(detected) > 0,
            "matches": detected
        }

if __name__ == "__main__":
    detector = CognitiveDistortionDetector()
    phrase = "J'ai raté cette PR, je suis incapable de coder et je serai viré d'ici un mois."
    rapport = detector.analyze(phrase)
    
    print(f"Texte : {rapport['input_text']}")
    for match in rapport["matches"]:
        print(f"- {match['distortion']} ({match['confidence'] * 100}%)")

Comment fonctionne ce script ?

Le fonctionnement repose sur trois mécanismes clairs :

• Le template d'hypothèse : En formulant "Ce texte illustre la distorsion cognitive suivante : {}", nous guidons le modèle NLI pour qu'il teste chaque étiquette de manière sémantique.
• Le mode multi-label : Une même pensée peut combiner plusieurs distorsions (par exemple catastrophisme et surgénéralisation). Le paramètre multi_label=True évalue chaque classe de façon indépendante.
• Le filtrage par seuil : L'analyse élimine les faux positifs en ne conservant que les correspondances dépassant une confiance arbitraire (ici 50 %).

Intégration dans une architecture full-stack

Ce script minimaliste constitue le socle parfait pour un microservice. En l’encapsulant dans une API légère avec FastAPI, vous pouvez exposer un point de terminaison POST /analyze consommable par une interface React ou Vue.js.

Les cas d'usage concrets sont nombreux : intégration dans une application de journal intime guidé, outil d'aide à la communication bienveillante pour équipes distantes, ou compagnon de relecture pour prendre du recul face au stress professionnel.

En moins de 60 lignes, le NLP moderne transforme un concept théorique issu de la psychothérapie en un composant logiciel actionnable et facilement déployable.