AI Prompt Engineering · Leçon

Explorer les arbres de pensée

Développer et évaluer les raisonnements.

Explorer les arbres de pensée est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Des chaînes aux arbres

L’arbre de pensées (ToT, Yao et al., 2023) généralise la chaîne de raisonnement, qui suit un seul chemin linéaire, en un arbre de recherche de solutions partielles. Chaque nœud représente une pensée intermédiaire cohérente ; les branches explorent différentes continuations.

Le modèle peut ainsi délibérer : générer plusieurs étapes suivantes, les évaluer, conserver les plus prometteuses et revenir en arrière depuis les impasses, en imitant une résolution systématique plutôt qu’en s’engageant sur la première idée venue.

class ThoughtNode:
    def __init__(self, state, parent=None):
        self.state = state      # partial solution / reasoning so far
        self.parent = parent
        self.children = []
        self.value = None       # evaluator score

Les quatre composants de ToT

Un système ToT repose sur quatre choix de conception : la décomposition de la pensée (ce qui constitue une étape), le générateur de pensées (la manière de proposer les étapes suivantes), l’évaluateur d’état (la manière de noter les solutions partielles) et l’algorithme de recherche (BFS, DFS ou recherche du meilleur candidat d’abord).

Chacun correspond à une instruction ou à une stratégie distincte. Concevoir ToT consiste à préciser les quatre pour votre tâche.

tot = {
    'decompose': step_definition,   # e.g. one equation, one move
    'generate':  propose_thoughts,  # sampling or proposal prompt
    'evaluate':  score_state,        # value/vote prompt
    'search':    bfs_with_beam,      # BFS | DFS | best-first
}

Générer des pensées candidates

Deux stratégies de génération sont possibles : échantillonner plusieurs pensées indépendantes à température modérée, ce qui convient lorsque l’espace est riche, ou proposer un ensemble d’étapes suivantes distinctes dans une seule instruction, ce qui convient lorsque vous voulez des options explicitement différentes.

Générez un petit facteur de branchement, souvent de 3 à 5 ; un nombre trop élevé de candidats fait exploser la recherche et les coûts.

def propose_thoughts(state, k=4):
    prompt = (
        'Given the partial solution below, propose ' + str(k) +
        ' DISTINCT possible next steps.\n' + state
    )
    return parse_list(llm(prompt, temperature=0.7))

Évaluer les états

L’évaluateur d’état est ce qui fait de ToT autre chose qu’un échantillonnage aléatoire. Il évalue le potentiel d’une solution partielle, soit avec une instruction de valeur (évaluez cet état de 1 à 10 selon sa progression vers la résolution du problème), soit avec une instruction de vote (lequel de ces états est le plus prometteur).

Le vote entre les candidats est souvent plus robuste qu’une notation absolue, car les jugements relatifs sont plus faciles pour le modèle.

def score_state(state):
    prompt = (
        'Rate how likely this partial solution leads to a correct '
        'final answer. Reply sure / likely / impossible.\n' + state
    )
    label = llm(prompt, temperature=0).strip().lower()
    return {'sure': 1.0, 'likely': 0.5, 'impossible': 0.0}.get(label, 0.3)

BFS avec recherche par faisceau

La recherche ToT en largeur développe tous les nœuds de la frontière, un niveau à la fois, puis ne conserve que les b meilleurs selon le score de l’évaluateur, formant ainsi un faisceau. Cela limite l’explosion tout en explorant plusieurs lignes en parallèle.

La largeur du faisceau b équilibre l’ampleur de l’exploration et le coût ; une largeur de 5 et une profondeur de 3 constituent un point de départ courant pour les casse-têtes structurés.

def bfs_with_beam(root, depth, branch, beam):
    frontier = [root]
    for _ in range(depth):
        nxt = []
        for node in frontier:
            for t in propose_thoughts(node.state, branch):
                child = ThoughtNode(node.state + '\n' + t, node)
                child.value = score_state(child.state)
                nxt.append(child)
        frontier = sorted(nxt, key=lambda n: -n.value)[:beam]
    return max(frontier, key=lambda n: n.value)

DFS avec retour en arrière

La recherche ToT en profondeur descend dans la branche la plus prometteuse et revient en arrière lorsque l’évaluateur juge un état sans espoir. Cette approche convient aux problèmes où un état partiel irréalisable est clairement identifiable, comme les casse-têtes à contraintes.

Élaguer rapidement les branches impossibles constitue le principal gain d’efficacité, car cela évite de développer inutilement des sous-arbres voués à l’échec.

def dfs(node, depth, branch, prune=0.2):
    if depth == 0 or is_solution(node.state):
        return node
    for t in propose_thoughts(node.state, branch):
        child = ThoughtNode(node.state + '\n' + t, node)
        child.value = score_state(child.state)
        if child.value < prune:
            continue                      # backtrack: prune dead end
        res = dfs(child, depth - 1, branch, prune)
        if res and is_solution(res.state):
            return res
    return None

ToT et auto-cohérence

L’auto-cohérence échantillonne des chaînes complètes indépendantes et procède à un vote. ToT dirige activement l’exploration grâce à l’évaluation intermédiaire et au retour en arrière, en investissant le calcul là où le potentiel est le plus élevé.

ToT est particulièrement efficace pour les problèmes qui nécessitent de la planification ou de la recherche, ou lorsque les premières erreurs sont irrémédiables, comme le jeu du 24, les mots croisés ou la planification. Pour les tâches où des chaînes diversifiées sont peu coûteuses et où la réponse est discrète, l’auto-cohérence est plus simple et souvent suffisante.

# Rule of thumb
# - reachable by diverse single passes  -> self-consistency
# - needs lookahead / pruning / backtrack -> tree-of-thought
# ToT cost ~ branch * depth * beam * (gen + eval) LLM calls

Explosion des coûts et budgets

ToT est coûteux : chaque nœud déclenche des appels de génération et d’évaluation. Le coût total évolue approximativement comme le facteur de branchement × la profondeur × le faisceau, auxquels s’ajoutent les appels de l’évaluateur. Sans budget strict, il peut rapidement devenir incontrôlable.

Plafonnez le nombre total d’appels à LLM, utilisez une recherche du meilleur candidat d’abord pour consacrer le budget à la frontière offrant le plus de valeur et revenez à la meilleure solution partielle si le budget est épuisé.

import heapq

def best_first(root, max_calls):
    heap = [(-root.value, root)]
    best, calls = root, 0
    while heap and calls < max_calls:
        _, node = heapq.heappop(heap)
        for t in propose_thoughts(node.state, 3):
            calls += 1
            child = ThoughtNode(node.state + '\n' + t, node)
            child.value = score_state(child.state); calls += 1
            if child.value > best.value:
                best = child
            heapq.heappush(heap, (-child.value, child))
    return best

Fiabilité de l’évaluateur

ToT n’est jamais meilleur que son évaluateur. Un évaluateur mal étalonné élimine les branches correctes ou poursuit des impasses. Améliorez-le avec des votes, c’est-à-dire plusieurs évaluations par état, des exemples en contexte d’états corrects et incorrects ou un vérificateur externe, comme un test unitaire, un solveur ou un vérificateur.

Lorsqu’une vérification objective existe, par exemple pour déterminer si l’équation est valide ou si le code s’exécute correctement, préférez-la au jugement d’un LLM.

def robust_eval(state, votes=3):
    scores = [score_state(state) for _ in range(votes)]
    return sum(scores) / votes        # average to reduce judge noise
# Even better: replace with a deterministic verifier when available

Applicabilité pratique

ToT est utile pour une catégorie étroite mais précieuse de problèmes : planification en plusieurs étapes, casse-têtes combinatoires et tâches où vérifier une étape coûte moins cher que résoudre l’ensemble. Pour la plupart des instructions courantes, ToT est excessif.

Avec les modèles nativement capables de raisonner et dotés d’une recherche intégrée efficace, une structure ToT explicite ajoute souvent des coûts sans apporter beaucoup de gains ; évaluez-la sur des données de référence avant de l’adopter.

def choose_strategy(task):
    if task.requires_search and task.step_verifiable:
        return 'tree-of-thought'
    if task.discrete_answer:
        return 'self-consistency'
    return 'single chain-of-thought'

Un solveur ToT minimal

De bout en bout : définissez une étape, proposez une petite branche de pensées, évaluez chacune d’elles avec un vote ou un vérificateur, effectuez une recherche BFS avec faisceau ou DFS avec retour en arrière dans la limite d’un budget d’appels, puis renvoyez le meilleur état terminal.

Enregistrez le nombre de nœuds et les scores de l’évaluateur afin d’ajuster empiriquement le facteur de branchement, la profondeur et le faisceau pour chaque tâche.

def solve(problem, branch=4, depth=3, beam=5, budget=200):
    root = ThoughtNode(problem)
    root.value = score_state(root.state)
    node = bfs_with_beam(root, depth, branch, beam)
    return extract_solution(node.state)

Vérification rapide

Choisissez la stratégie de délibération appropriée.

Récapitulatif

Points clés à retenir :

ToT généralise CoT en un arbre de recherche doté d’un générateur de pensées, d’un évaluateur d’état et d’un algorithme de recherche.
Utilisez BFS avec un faisceau ou DFS avec retour en arrière ; gardez un faible facteur de branchement pour maîtriser l’explosion.
L’évaluateur d’état est l’élément central ; renforcez-le avec des votes ou un vérificateur externe.
Le coût évolue comme le facteur de branchement × la profondeur × le faisceau ; imposez donc un budget d’appels, souvent au moyen d’une recherche du meilleur candidat d’abord.
Réservez ToT aux problèmes de planification ou combinatoires dont les étapes sont vérifiables ; cette méthode est excessive pour les instructions courantes.

Questions Fréquemment Posées

La leçon « Explorer les arbres de pensée » est-elle gratuite ?

Oui — le texte complet de « Explorer les arbres de pensée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Explorer les arbres de pensée » ?

Développer et évaluer les raisonnements. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Explorer les arbres de pensée » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Prompts avec raisonnement explicite
Échantillonnage par auto-cohérence
Explorer les arbres de pensée
Quand les prompts de raisonnement sont utiles

← Retour à AI Prompt Engineering