Parallelization

Aussi appelé : fan-out / fan-in, scatter-gather, concurrent orchestration (Microsoft), parallel agent (Google ADK), sectioning, voting, self-consistency, best-of-N, map-reduce

Intention

Lancer plusieurs appels LLM en même temps sur des morceaux de travail qui ne dépendent pas les uns des autres, puis combiner leurs sorties en une seule étape d'agrégation. Les branches sont soit des sous-tâches différentes (sectioning, découpage en sections), soit la même tâche exécutée plusieurs fois (voting, vote). Votre code fixe le découpage avant le début de l'exécution : c'est ce qui distingue ce pattern d'un orchestrateur qui invente les sous-tâches en cours de route.

Problème

Vous construisez un outil d'audit d'acquisition (due diligence) pour une petite équipe d'investissement. Une analyste charge la data room d'Acme Robotics (documents sociaux, trois ans d'états financiers, les principaux contrats clients, une étude de marché) et demande : Acme est-elle une cible d'acquisition raisonnable ?

L'outil a besoin d'une revue juridique, d'une revue financière et d'une revue de marché. Aucune n'a besoin du résultat des autres. Les premières versions de l'outil échouent de trois façons :

La data room passe par une revue juridique, puis financière, puis de marché, l'une après l'autre : le rapport n'arrive qu'après environ 60 secondes alors qu'aucune revue ne dépend d'une autre. Data room Juridique revue, 20 s Finance revue, 20 s Marché revue, 20 s Rapport après 60 s 60 s d'attente, alors qu'aucune revue n'a besoin d'une autre (tout fusionner en un seul prompt va plus vite, mais chaque sujet reçoit moins d'attention)
Les trois revues sont indépendantes, mais la version séquentielle fait attendre chacune la précédente.

Solution

Écrivez le découpage dans le code. Lancez un appel LLM par morceau indépendant, tous en même temps, attendez-les à une barrière, puis remettez tous les résultats à un agrégateur. Chaque branche ne voit que son propre prompt et l'entrée partagée ; les branches ne communiquent jamais entre elles pendant l'exécution.

  1. Découper. Le code construit la liste des tâches de branche : legal_review, financial_review, market_review, chacune avec son prompt ciblé et la même data room.
  2. Fan-out. Les trois appels démarrent ensemble, sous un plafond de concurrence et avec un timeout par branche.
  3. Travail des branches. Chaque relecteur renvoie du JSON selon un schéma connu : une liste de constats avec gravité et preuves.
  4. Fan-in. Une barrière attend que toutes les branches aient terminé, qu'un quorum soit atteint ou qu'une échéance soit dépassée. Les branches en échec sont enregistrées, pas masquées.
  5. Agréger. Un LLM fusionne les trois rapports en une synthèse des risques. Il conserve chaque risque distinct, indique quel relecteur l'a soulevé, expose les désaccords et marque une revue manquante comme « non disponible ».
  6. Renvoyer le rapport avec ses métadonnées : quelles branches ont réussi, et si le résultat est dégradé.

C'est le sectioning : une sous-tâche différente dans chaque branche. La seconde variante, le voting, exécute la même tâche plusieurs fois et agrège les réponses. Dans le même outil, trois relecteurs pourraient chacun lire les contrats clients à la recherche de clauses de changement de contrôle, et le code signalerait une clause dès que l'un d'eux la rapporte. Les deux termes viennent de « Building effective agents », d'Anthropic.

Qui décide du flux : le développeur. Le code fixe la façon de découper, le nombre de branches, les prompts et les modèles, les limites et la règle d'agrégation. Les LLM ne décident que du contenu de chaque branche et, éventuellement, du texte fusionné. Dans Orchestrator–Workers, le fan-out a la même forme, mais un LLM principal décide à l'exécution combien de sous-tâches existent et ce que couvre chacune.

Analogie

Un acheteur sur le point d'acquérir un immeuble envoie le même dossier à un avocat, un expert-comptable et un géomètre le lundi matin. Ils travaillent dans des bureaux séparés et ne s'appellent jamais. Le vendredi, l'acheteur lit les trois rapports côte à côte et rédige une note de décision. L'acheteur a choisi les trois experts avant d'envoyer quoi que ce soit : c'est le découpage décidé par le développeur. La note de décision, c'est l'agrégateur.

Pour le vote, imaginez demander à deux experts en bâtiment leur avis sur la toiture et agir si l'un des deux trouve un dégât. L'analogie s'arrête au coût : les experts humains sont lents et chers, alors qu'une branche LLM de plus coûte peu par appel, mais multiplie votre facture de tokens et la pression sur vos limites de débit.

Structure

La data room va à un répartiteur écrit en code, qui lance en même temps trois appels de revue isolés ; leurs résultats vont à une barrière de fan-in, puis à un agrégateur qui produit le rapport avec le statut de chaque branche. lancées en même temps : 3 en vol au plus, timeout de 60 s chacune Data room Répartiteur code, fixe Revue juridique appel LLM isolé Revue financière appel LLM isolé Revue de marché appel LLM isolé Fan-in attend toutes Agrégateur synthèse par LLM Rapport statut par branche 1 2 3 4 5
Les flèches d'accent sont le fan-out, que lance le code. Les flèches en pointillé ramènent les résultats des branches. Avec le voting, les trois boîtes contiendraient le même prompt et l'agrégateur serait un vote dans le code.
  1. Répartiteur. Du code qui transforme l'entrée en liste de tâches de branche et garantit qu'elles sont indépendantes. En map-reduce, c'est un découpeur de texte qui crée une tâche par fragment.
  2. Branches. Un appel LLM (ou un agent complet avec ses outils) par sous-tâche ou par échantillon. Chacune reçoit son propre prompt et renvoie un résultat selon un schéma connu. Un ordonnanceur les lance ensemble et applique le plafond de concurrence, les timeouts et les nouvelles tentatives.
  3. Barrière de fan-in. Attend toutes les branches, un quorum, une échéance, ou une sortie anticipée comme le déclenchement d'un garde-fou. Elle enregistre quelles branches ont échoué.
  4. Agrégateur. Transforme N sorties en une seule : une fonction pure (concaténation, union, vote, seuil k sur N) ou un LLM (synthèse, sélection). Choisissez la règle avant d'écrire les prompts, car elle détermine le schéma de sortie.
  5. Résultat avec métadonnées. La réponse fusionnée, plus branches_ok, branches_failed, degraded et, pour le vote, le décompte des voix et la marge.

Générateur de prompt

Décrivez l'entrée partagée et une ligne par branche. La sortie comporte quatre parties : une spécification d'exécution pour votre code de fan-out (limites, politique d'échec, règle d'agrégation), le bloc d'entrée partagée, un prompt par branche, et le prompt ou la règle de l'agrégateur. Utilisez-les avec un simple asyncio.gather, un fan-out LangGraph ou l'étape parallèle de n'importe quel framework.

Variante
Branches une ligne par sous-tâche (voting : par variante de prompt)
Quand une branche échoue

Prompt généré

Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.

D'où vient la qualité

L'essentiel du travail porte sur les contrats d'interface, plus que sur la formulation. Donnez aux branches des périmètres qui ne se recouvrent pas, faites renvoyer à chaque branche du JSON typé, et décidez d'abord de la règle d'agrégation. Un prompt de synthèse nourri de N dissertations libres, c'est là que les détails se perdent ; un vote sur un champ final_answer normalisé est facile à réussir.

Quand l'utiliser

À utiliser quand

À éviter quand

Mise en œuvre

  1. Prouvez l'indépendance. Dessinez le graphe de dépendances des sous-tâches. Toute arête entre deux d'entre elles est une chaîne, pas une branche.
  2. Choisissez la variante. Des sujets différents : sectioning. La même question avec un besoin de fiabilité : voting. Une entrée trop grande ou de nombreux éléments : map-reduce.
  3. Définissez une sortie structurée par branche. Incluez un branch_id stable, un status (ok, error, timeout, invalid), la charge utile et, pour le vote, un final_answer normalisé.
  4. Choisissez la règle d'agrégation avant les prompts. Concaténation, union et dédoublonnage, vote majoritaire, seuil k sur N, best-of-N avec un vérificateur, ou synthèse par LLM. La règle détermine le schéma.
  5. Fixez des limites. Un plafond de concurrence sous la limite de débit de votre fournisseur, un timeout par branche, une échéance globale, des nouvelles tentatives avec backoff sur HTTP 429, et une politique d'échec : tout ou rien, au mieux avec un indicateur degraded, ou quorum.
  6. Triez avant de fusionner. L'ordre de complétion n'est pas stable (LangGraph et Semantic Kernel le précisent tous les deux) : triez donc les résultats par branch_id et utilisez une règle de départage fixe.
  7. Tracez sous un seul span parent, avec un span enfant par branche, pour voir les N appels côte à côte. L'exemple de parallélisation d'OpenAI regroupe toutes les exécutions dans une seule trace.
  8. Mesurez par rapport à un appel unique de référence sur la précision, la latence p50/p95 et le coût par tâche avant de garder les branches supplémentaires. Retirez une branche à la fois pour vérifier que chacune justifie son coût.

En Python pur, le cœur est un asyncio.gather sur les appels de branche, enveloppés dans un sémaphore et asyncio.wait_for. La plupart des frameworks proposent une primitive nommée pour la même chose :

Prise en charge par les frameworks (vérifiez la documentation actuelle avant usage)
FrameworkFan-outFan-in
LangGraphPlusieurs arêtes depuis un nœud ; Send pour un map dynamiqueReducers sur les clés d'état ; arête sous forme de liste add_edge(["a","b"], "merge") ; defer=True
LangChain (LCEL)RunnableParallel ; batch avec max_concurrencyUn dict indexé par nom de branche
OpenAI Agents SDKasyncio.gather sur Runner.runVotre code, ou un agent sélecteur
Google ADKParallelAgent(sub_agents=[...])Un output_key distinct par branche dans l'état de session, puis un agent de fusion
CrewAITask(async_execution=True)Une tâche ultérieure avec context=[...]
LlamaIndex Workflowssend_event plusieurs fois ; num_workerscollect_events
Microsoft Agent FrameworkConcurrentBuilder, AddFanOutEdgeAgrégateur par défaut ou personnalisé ; AddFanInBarrierEdge
Semantic KernelConcurrentOrchestrationListe de résultats, ordre non garanti

Deux comportements de LangGraph sont bons à connaître. Un superstep est transactionnel : si une branche parallèle lève une exception, aucune des mises à jour d'état de cette étape n'est appliquée, et une RetryPolicy ne relance que la branche en échec. Une arête sous forme de liste ne se déclenche jamais, sans aucun avertissement, si l'un des nœuds listés ne s'exécute pas.

Mise en garde. Ces API évoluent vite. Google ADK marque les workflow agents à gabarit, ParallelAgent compris, comme dépréciés au profit des workflows à base de graphe, sans date de suppression annoncée. L'API d'orchestration de Semantic Kernel est expérimentale. Vérifiez les noms dans la documentation actuelle.

Variantes

Sectioning

Une liste fixe d'appels différents, comme dans l'exemple suivi. Les exemples d'Anthropic sont un garde-fou qui tourne à côté de la réponse principale et des évaluations automatisées où chaque appel note un aspect (fidélité, ton, exhaustivité).

Garde-fous en parallèle

Un cas de sectioning où une branche peut opposer son veto à l'autre. L'OpenAI Agents SDK exécute par défaut les garde-fous d'entrée en même temps que l'agent, et propose un mode bloquant. Le compromis qu'il documente : en mode parallèle, l'agent peut déjà avoir dépensé des tokens et lancé des outils avant que le garde-fou ne se déclenche. Ne lancez jamais d'outils à effets de bord dans une branche qu'un garde-fou parallèle peut encore annuler.

Vote et self-consistency

Le même prompt, N échantillons à une température supérieure à zéro, un vote majoritaire sur la réponse extraite. Wang et al. ont échantillonné 40 chemins de raisonnement et rapporté +17,9 points sur GSM8K par rapport à un chain-of-thought simple, mais l'essentiel du gain arrivait dès 5 à 10 chemins. Dans leur comparaison des méthodes d'agrégation, un vote majoritaire simple (74,4 %) égalait la meilleure variante pondérée, tandis qu'une pondération par les probabilités non normalisées du modèle tombait à 59,9 %. Ces résultats portent sur des modèles de 2022 ; les gains sur les modèles actuels sont probablement plus faibles sur les benchmarks saturés. La méthode exige des réponses issues d'un ensemble fixe.

Perturbation du prompt et de l'entrée

Faites varier le prompt au lieu de la température, ou en plus. L'ensemble à mélange des choix de Medprompt lance 5 appels avec les options de QCM dans un ordre différent et retient la réponse la plus fréquente ; il a apporté environ 2,2 points dans l'ablation des auteurs. Le mélange contrebalance aussi le biais de position.

Panels multi-modèles

Des modèles différents répondent ou jugent, puis votent. Dans l'étude PoLL, un panel de petits juges issus de familles de modèles différentes a battu un seul grand juge pour un coût plus de sept fois inférieur, avec moins de biais d'auto-préférence. Dès que les juges se lisent et se critiquent les uns les autres, on passe à Council / Debate.

Universal self-consistency

Pour les sorties en texte libre, où un vote à correspondance exacte est impossible, un LLM lit tous les candidats et choisit celui qui est le plus cohérent avec les autres. L'article indique que la méthode égale la self-consistency standard en mathématiques et le vote fondé sur l'exécution pour le code.

Best-of-N avec un vérificateur

Générez N candidats et gardez celui qu'un vérificateur note le plus haut : tests unitaires, vérificateur entraîné ou juge LLM. Avec un vérificateur automatique, cela passe très bien à l'échelle : dans « Large Language Monkeys », le taux de résolution sur SWE-bench Lite passe de 15,9 % avec un échantillon à 56 % avec 250. Sans vérificateur fiable, la sélection plafonne au-delà de quelques centaines d'échantillons.

Map-reduce

Le nombre de branches vient des données (fragments, fichiers, lignes), mais l'opération par branche est fixe. Quand les résumés produits par le map restent trop longs pour un seul appel de reduce, une étape de compactage les réduit par groupes. Bornez cette boucle : l'exemple de LangChain utilise une limite de récursion de 10.

Skeleton-of-Thought

Le modèle écrit d'abord un plan court, puis chaque point est développé en parallèle. L'article rapporte des accélérations jusqu'à 2,39x, avec une qualité qui tient sur les questions de connaissances et de sens commun, mais qui baisse en mathématiques, en code et en rédaction. Le plan est généré à l'exécution, ce qui rapproche cette variante d'Orchestrator–Workers.

Appels d'outils en parallèle

Le modèle émet plusieurs appels d'outils dans un même tour et votre code les exécute en même temps. Ici, c'est le modèle qui décide du fan-out : cette variante se situe donc entre ce pattern et la boucle ReAct. La documentation de Claude exige tous les résultats d'outils dans un seul message utilisateur ; les répartir sur plusieurs messages apprend au modèle à ne plus appeler d'outils en parallèle.

Avantages et inconvénients

Avantages

  • Le temps réel tombe à celui de la branche la plus lente plus la fusion quand les sous-tâches sont indépendantes.
  • Chaque branche a un prompt court et ciblé, et les branches simples peuvent utiliser un modèle plus petit.
  • Le vote améliore la précision sur les réponses de forme fixe et fournit gratuitement un signal de confiance (la marge du vote).
  • Le flux est fixé dans le code : il est prévisible, facile à tester branche par branche, et peu coûteux comparé aux patterns à base d'agents.
  • Un seuil k sur N permet d'arbitrer entre rappel et précision sans toucher aux prompts.

Inconvénients

  • Environ N fois les tokens d'un appel, plus l'agrégation. Le vote ne réduit pas la latence ; il ajoute l'échantillon le plus lent et l'agrégateur.
  • N requêtes simultanées atteignent plus vite les limites de débit.
  • Plus d'appels, c'est plus de risques d'échec par exécution : il vous faut des timeouts, des nouvelles tentatives et une politique d'échec.
  • L'étape d'agrégation est un problème de conception à part entière, et un LLM de synthèse peut perdre des détails ou inventer un accord.
  • L'ordre de complétion aléatoire et l'échantillonnage rendent les exécutions difficiles à reproduire, sauf si vous triez et fixez les règles de départage.

Modes de défaillance

Dépendance cachée

La revue financière avait besoin d'un fait trouvé par la revue juridique (par exemple, un contrat qui prend fin en cas de changement de contrôle). Les deux rapports se contredisent et la fusion ne peut pas dire pourquoi.

Parade : dessinez le graphe de dépendances avant de construire ; enchaînez les étapes dépendantes au lieu de les paralléliser.

Tempête de limites de débit

Toutes les branches partent en même temps, beaucoup reçoivent un HTTP 429, et des nouvelles tentatives naïves aggravent la rafale.

Parade : un sémaphore sous la limite du fournisseur, un backoff exponentiel avec jitter, ou le max_concurrency / num_workers du framework.

Branche retardataire

Une branche lente fixe la latence totale. Anthropic note que dans son système de recherche, l'agent principal attend ses sous-agents de façon synchrone, si bien qu'un sous-agent lent bloque toute l'étape.

Parade : un timeout par branche, une échéance globale ou un quorum, et un résultat marqué comme dégradé.

Échec partiel silencieux

Une branche échoue et l'agrégateur fusionne le reste comme si de rien n'était. Le rapport n'a pas de section marché, ou un vote est biaisé par les échantillons manquants.

Parade : une politique explicite (tout ou rien, au mieux avec un indicateur degraded, ou quorum) et une consigne à l'agrégateur d'écrire « non disponible » pour les parties manquantes.

Effets de bord avant le déclenchement d'un garde-fou

La branche principale a déjà dépensé des tokens ou appelé un outil au moment où le garde-fou parallèle bloque la requête.

Parade : tenez les outils à effets de bord hors de la branche principale tant que le garde-fou n'a pas répondu, ou utilisez le mode bloquant.

Conflits d'état partagé

Deux branches écrivent la même clé ou le même enregistrement, et l'une écrase l'autre. Microsoft classe l'état mutable partagé entre agents concurrents parmi les anti-patterns.

Parade : une clé de sortie distincte par branche, des reducers qui fusionnent les écritures concurrentes, et des écritures uniquement dans l'agrégateur.

Erreurs d'extraction des réponses

« 42 », « 42.0 » et « quarante-deux » comptent comme trois votes différents, et des sorties impossibles à parser se glissent dans le décompte.

Parade : demandez un champ final_answer normalisé, normalisez avant de compter, et comptez à part les sorties impossibles à parser.

Erreurs corrélées

Tous les échantillons partagent le même biais, et la majorité se trompe avec assurance.

Parade : diversifiez les branches (prompts différents, options mélangées, familles de modèles différentes) et utilisez un vérificateur exécutable quand c'est possible.

Trop de votes

Chen et al. montrent que, sur des tâches de difficulté hétérogène, la précision peut monter puis baisser à mesure que les appels augmentent, car les appels supplémentaires aident sur les requêtes faciles et nuisent sur les difficiles.

Parade : faites varier N sur un jeu de développement (par exemple 1, 3, 5, 10) et tracez la précision en fonction du coût au lieu de maximiser N.

Agrégateur surchargé

L'appel de synthèse reçoit N longs rapports, dépasse sa fenêtre de contexte ou perd des détails.

Parade : des sorties de branche structurées et de longueur plafonnée, et un reduce hiérarchique quand les branches sont nombreuses.

Liens avec les autres patterns

Pour aller plus loin

Toutes les sources sont en anglais.