Graph of Thoughts Prompting : fonctionnement et quand l'utiliser (vs Chain/Tree)

L'évolution des techniques de raisonnement

De la chaîne à l'arbre, puis au graphe

Chain of Thought (CoT) :
A → B → C → D → Réponse
(Linéaire, chemin unique)

Tree of Thought (ToT) :
        A
       /|\
      B C D
     /|   |\
    E F   G H
(Ramification, mais pas de fusion)

Graph of Thoughts (GoT) :
        A
       /|\
      B C D
     /|\ /|\
    E F G H
     \|/|\|/
      I J
       \|
     Réponse
(Ramification ET fusion)

Qu'est-ce que le Graph of Thoughts ?

Concept fondamental

Le Graph of Thoughts (GoT) représente le raisonnement de l'IA sous forme de graphe orienté où :

• →Nœuds = Pensées (étapes de raisonnement intermédiaires)
• →Arêtes = Dépendances ou transformations entre les pensées
• →Opérations = Générer, agréger, affiner, évaluer

Contrairement aux arbres qui ne font que se ramifier, les graphes permettent :

• →La fusion de plusieurs idées en une seule
• →Le bouclage pour affiner les pensées antérieures
• →Le vote entre plusieurs solutions
• →L'agrégation des meilleurs éléments de différents chemins

Le framework GoT

Opérations :

Structure du graphe :

Pourquoi le graphe surpasse l'arbre

L'avantage de la fusion

Considérons le tri d'une liste de nombres. Avec le ToT :

Problème : Trier [3, 1, 4, 1, 5, 9, 2, 6]

Approche ToT :
Branche 1 : Essayer le tri à bulles → [1, 1, 2, 3, 4, 5, 6, 9]
Branche 2 : Essayer le tri fusion → [1, 1, 2, 3, 4, 5, 6, 9]
Branche 3 : Essayer le tri rapide → [1, 1, 2, 3, 4, 5, 6, 9]

Résultat : Choisir la meilleure branche (toutes identiques, calcul gaspillé)

Avec le GoT :

Problème : Trier [3, 1, 4, 1, 5, 9, 2, 6]

Approche GoT :
1. Diviser : [3, 1, 4, 1] et [5, 9, 2, 6]
2. Traiter chaque partie : [1, 1, 3, 4] et [2, 5, 6, 9]
3. Opération MERGE : Combiner les sous-listes triées
4. Résultat : [1, 1, 2, 3, 4, 5, 6, 9]

Utilise efficacement le diviser pour régner !

La boucle d'affinement

Le GoT permet d'améliorer les pensées :

Pensée initiale : "Le chiffre d'affaires a augmenté grâce au marketing"

REFINE avec des données :
"Le chiffre d'affaires a augmenté de 23 % après le lancement de la campagne"

REFINE avec du contexte :
"Le chiffre d'affaires a augmenté de 23 % au T3 après la campagne d'influenceurs,
dépassant la projection de 15 % de 8 points de pourcentage"

Chaque affinement ajoute de la précision sans repartir de zéro.

Les quatre opérations du GoT

1. GENERATE

Créer de nouvelles pensées à partir de pensées existantes :

Modèle de prompt :
"Étant donné cette pensée : [PENSÉE]
Générez [N] nouvelles pensées qui prolongent ou développent cette idée.
Chacune doit explorer une direction différente."

Exemple :
Entrée : "L'application est lente"
Générer 3 pensées :
1. "L'application est lente à cause des requêtes de base de données trop longues"
2. "L'application est lente à cause d'un goulot d'étranglement de rendu frontend"
3. "L'application est lente à cause de la latence réseau avec les appels API"

2. AGGREGATE

Combiner plusieurs pensées en une seule :

Modèle de prompt :
"Vous avez ces [N] solutions partielles :
[PENSÉE 1]
[PENSÉE 2]
[PENSÉE 3]

Combinez les meilleurs éléments en une seule solution cohérente."

Exemple :
Pensée 1 : "Utiliser le cache pour les requêtes de base de données"
Pensée 2 : "Implémenter le chargement différé pour le frontend"
Pensée 3 : "Activer la compression pour les réponses API"

Agrégation : "Implémenter une optimisation multi-couche : mettre en cache
les requêtes de base de données, charger les composants frontend en différé
et compresser les payloads API — adressant les trois types de goulots 
d'étranglement."

3. REFINE

Améliorer une pensée à partir de retours :

Modèle de prompt :
"Voici une pensée : [PENSÉE]
Voici un retour : [RETOUR]

Affinez la pensée pour prendre en compte le retour tout en
préservant son insight fondamental."

Exemple :
Pensée : "Nous devrions utiliser Redis pour le cache"
Retour : "Redis nécessite une infrastructure supplémentaire"
Affinée : "Nous devrions utiliser Redis pour le cache, avec AWS
ElastiCache pour une infrastructure managée afin de minimiser
la charge opérationnelle."

4. SCORE

Évaluer la qualité d'une pensée :

Modèle de prompt :
"Évaluez cette pensée selon ces critères :
- Justesse (0-10)
- Complétude (0-10)
- Faisabilité (0-10)

Pensée : [PENSÉE]

Fournissez les scores et une brève justification pour chacun."

Exemple :
Pensée : "Migrer vers une architecture microservices"
Scores :
- Justesse : 7 (solution valide pour la scalabilité)
- Complétude : 5 (stratégie de migration manquante)
- Faisabilité : 4 (effort significatif pour une petite équipe)
Moyenne : 5,3

Implémenter le GoT Prompting

Implémentation de base

class GraphOfThoughts:
    def __init__(self, llm):
        self.llm = llm
        self.thoughts = {}  # id -> thought
        self.graph = {}     # id -> [successor_ids]
        
    def generate(self, parent_id: str, n: int = 3) -> list:
        parent = self.thoughts[parent_id]
        new_thoughts = self.llm.complete(
            f"Given: {parent}\nGenerate {n} distinct extensions:"
        )
        # Parse and store new thoughts
        ids = []
        for thought in self.parse_thoughts(new_thoughts):
            id = self.add_thought(thought, parent_id)
            ids.append(id)
        return ids
    
    def aggregate(self, thought_ids: list) -> str:
        thoughts = [self.thoughts[id] for id in thought_ids]
        combined = self.llm.complete(
            f"Combine these thoughts:\n" + 
            "\n".join(thoughts) +
            "\nInto one coherent solution:"
        )
        return self.add_thought(combined, thought_ids)
    
    def refine(self, thought_id: str, feedback: str) -> str:
        thought = self.thoughts[thought_id]
        refined = self.llm.complete(
            f"Thought: {thought}\nFeedback: {feedback}\nRefined:"
        )
        return self.add_thought(refined, [thought_id])
    
    def score(self, thought_id: str) -> float:
        thought = self.thoughts[thought_id]
        scores = self.llm.complete(
            f"Score (0-10) for correctness, completeness, " +
            f"feasibility:\n{thought}"
        )
        return self.parse_scores(scores)

GoT uniquement par prompt

Sans code, vous pouvez appliquer les principes du GoT dans vos prompts :

## Étape 1 : Générer plusieurs approches

"Pour ce problème : [PROBLÈME]

Générez 3 approches différentes pour le résoudre.
Chaque approche doit être significativement différente."

## Étape 2 : Développer chaque approche

"Prenez l'approche n°2 et développez-la davantage. Quelles sont les
étapes clés ? Quels sont les problèmes potentiels ?"

## Étape 3 : Agréger les meilleurs éléments

"En considérant les trois approches :
- Approche 1 : [résumé]
- Approche 2 : [résumé]
- Approche 3 : [résumé]

Combinez les meilleurs éléments de chacune en une seule solution.
Conservez les forces, adressez les faiblesses."

## Étape 4 : Affiner avec des contraintes

"Cette solution : [AGRÉGÉE]

Doit aussi satisfaire ces contraintes : [CONTRAINTES]

Affinez la solution pour respecter toutes les contraintes tout en
préservant l'efficacité."

## Étape 5 : Évaluer

"Évaluez la solution finale :
- Résout-elle le problème original ? (0-10)
- Est-elle complète ? (0-10)
- Est-elle pratique ? (0-10)

Si un score est inférieur à 7, quelle amélioration spécifique est nécessaire ?"

Quand utiliser le GoT

Types de problèmes idéaux

Problèmes décomposables :

• →Peuvent être divisés en sous-problèmes
• →Les solutions aux parties peuvent être combinées
• →Exemples : tri, planification, optimisation

Problèmes multi-perspectives :

• →Bénéficient de points de vue divers
• →La vérité émerge de la synthèse
• →Exemples : décisions de conception, stratégie

Problèmes sensibles à l'affinement :

• →Les premières réponses nécessitent des itérations
• →Les retours améliorent la qualité
• →Exemples : rédaction, débogage

Cadre de décision GoT

Flux de décision :

1. →

   Le problème est-il simple et linéaire ?

   • →Oui → Utilisez le Chain of Thought
   • →Non → Passez à l'étape 2
2. →

   Le problème bénéficie-t-il de l'exploration d'alternatives ?

   • →Non → Utilisez le Chain of Thought
   • →Oui → Passez à l'étape 3
3. →

   Les solutions partielles peuvent-elles être combinées de manière pertinente ?

   • →Non → Utilisez le Tree of Thought
   • →Oui → Passez à l'étape 4
4. →

   La solution bénéficie-t-elle de boucles d'affinement ?

   • →Non → Envisagez le Tree of Thought
   • →Oui → Utilisez le Graph of Thoughts

Exemples pratiques

Exemple 1 : Analyse de stratégie d'entreprise

Problème : Comment devons-nous répondre à un nouveau concurrent ?

Approche GoT :

[GENERATE] Pensées initiales :
T1 : "Baisser les prix pour concurrencer sur les coûts"
T2 : "Se différencier par la qualité et le service"
T3 : "S'étendre vers des marchés qu'ils n'ont pas encore investis"

[GENERATE] Développer chacune :
T1a : "Réduction de prix de 10 %, accepter l'impact sur la marge"
T1b : "Améliorations d'efficacité pour permettre des prix plus bas"
T2a : "Offre premium avec support amélioré"
T2b : "Se concentrer sur les fonctionnalités qu'ils n'ont pas"
T3a : "Expansion internationale"
T3b : "Pénétrer des segments de marché adjacents"

[AGGREGATE] Combiner T2a + T2b + T3b :
"Lancer une offre premium axée sur des fonctionnalités et un
support inégalés, tout en s'étendant vers des segments adjacents
qu'ils ignorent — en évitant la concurrence directe par les prix."

[REFINE] Avec contrainte budgétaire :
"Prioriser le lancement de l'offre premium (T2) avec les
ressources existantes, reporter l'expansion de segment au T4 en
attendant les résultats. Maintenir les prix actuels."

[SCORE] :
- Traitement de la menace : 8/10 (indirect mais efficace)
- Faisabilité : 9/10 (approche par phases)
- Risque : 7/10 (réaction du marché incertaine)

Stratégie finale prête pour la revue de direction.

Exemple 2 : Conception d'architecture de code

Problème : Concevoir un système d'authentification pour une nouvelle application

[GENERATE] Options d'architecture :
T1 : Authentification stateless basée sur JWT
T2 : Authentification serveur basée sur les sessions
T3 : OAuth2 avec fournisseurs tiers uniquement

[GENERATE] Avantages/inconvénients de chaque option :
T1-pro : Scalable, pas d'état serveur
T1-con : Révocation de token complexe
T2-pro : Révocation facile, contrôle serveur
T2-con : Gestion d'état, défis de scalabilité
T3-pro : Pas de gestion de mots de passe
T3-con : Dépendance aux fournisseurs, friction utilisateur

[AGGREGATE] T1 + éléments de T2 :
"JWT pour l'authentification standard avec expiration courte (15 min),
associé à un stockage serveur de refresh tokens pour la capacité
de révocation. On obtient la scalabilité du JWT avec le contrôle
de la gestion de sessions."

[REFINE] Ajouter les exigences de sécurité :
"JWT (15 min) + refresh tokens (30 jours) stockés dans
Redis. Refresh tokens invalidés au changement de mot de passe.
Ajouter limitation de débit et empreinte d'appareil."

[AGGREGATE] Ajouter T3 :
"Supporter les fournisseurs OAuth2 (Google, Apple) parallèlement à
l'implémentation personnalisée JWT+refresh. Les utilisateurs OAuth
obtiennent des comptes liés, pouvant ajouter un mot de passe ensuite."

Résultat : Système hybride répondant à toutes les exigences.

Patterns GoT avancés

Boucle d'affinement itératif

répéter :
    thought = generate()
    score = evaluate(thought)
    si score >= seuil :
        retourner thought
    feedback = identify_weaknesses(thought)
    thought = refine(thought, feedback)
jusqu'à max_iterations

Agrégation d'ensemble

Générer N solutions indépendantes
Évaluer chaque solution
Filtrer les K meilleures
Agréger les K meilleures en une méga-solution
Affiner la méga-solution
Retourner le résultat final

GoT hiérarchique

Structure :

• →Graphe de haut niveau pour la stratégie
  • →Sous-graphe pour le composant A
  • →Sous-graphe pour le composant B
  • →Sous-graphe pour le composant C

Processus : Chaque sous-graphe est résolu indépendamment, puis les résultats sont agrégés au niveau supérieur.

GoT vs autres techniques

Points clés à retenir

1. →

   Le Graph of Thoughts étend le Tree of Thought en ajoutant l'agrégation, l'affinement et les boucles

2. →

   Quatre opérations fondamentales : Generate, Aggregate, Refine, Score

3. →

   L'avantage clé est la combinaison : le GoT peut fusionner des solutions partielles en ensembles plus forts

4. →

   Idéal pour les problèmes décomposables où les solutions peuvent être combinées et affinées

5. →

   Peut être implémenté en code ou en prompts purs via des approches structurées multi-étapes

6. →

   La complexité accrue implique un coût plus élevé — à utiliser quand les méthodes plus simples ne suffisent pas

7. →

   Pratique pour des problèmes réels comme la stratégie, l'architecture et l'analyse complexe

Maîtrisez les techniques avancées de prompting

Le Graph of Thoughts est l'une des nombreuses techniques avancées de prompting qui améliorent considérablement le raisonnement de l'IA pour les problèmes complexes. Comprendre l'ensemble des outils vous aide à choisir la bonne approche.

Dans notre Module 3 — Techniques avancées de prompting, vous apprendrez :

• →Les fondamentaux du Chain-of-Thought
• →Les stratégies de ramification Tree-of-Thought
• →La Self-consistency pour des réponses robustes
• →Le Step-back prompting pour la prise de recul
• →Quand utiliser chaque technique
• →Combiner les techniques pour un effet maximal

Ces compétences vous aideront à résoudre des problèmes que le prompting basique ne peut pas traiter.

→ Explorer le Module 3 : Techniques avancées de prompting