Module 5 · Section 5.5

Visualisation d'arbres

50 min · niveau debutant · dernière révision : 2026-11-01

Objectifs d'apprentissage

Décoder une chaîne Newick et en extraire la topologie, les longueurs de branches et les supports
Distinguer un arbre enraciné d'un arbre non enraciné et justifier la position de la racine
Joindre un tableau de métadonnées aux feuilles et construire une figure lisible avec couleurs, légende et échelle
Interpréter les supports bootstrap et les probabilités postérieures sans les confondre
Produire une figure reproductible avec FigTree, iTOL ou ETE et documenter chaque choix

Prérequis : 5.3 Neighbor-Joining et bootstrap

FigTree 1.4.4iTOL webETE 4.x

Prérequis

Cette section s'appuie sur la construction d'un arbre Neighbor-Joining et sur la lecture d'un support bootstrap, vus en 5.3. Elle suppose connues les distances évolutives de 5.2 et la notion d'alignement multiple de 5.1. Le vocabulaire des arbres — feuille, nœud interne, branche, clade, bipartition — est utilisé sans être redéfini. Les fichiers d'exemple sont lus depuis la racine du dépôt, et les positions restent 1-based dans le texte.

Introduction

Un arbre phylogénétique n'est pas seulement une image : c'est une hypothèse sur l'histoire des lignées, condensée dans une topologie, des longueurs de branches et, souvent, des supports. Une figure mal lue peut faire croire qu'un groupe est certain alors que la branche qui le porte est fragile, ou qu'une espèce est l'ancêtre d'une autre alors que la racine a été placée arbitrairement. À l'inverse, une figure bien construite rend immédiatement visibles la structure des données, les incertitudes et les annotations biologiques qui importent pour la question posée.

L'enjeu computationnel est double. Il faut d'abord représenter l'arbre dans un format fidèle et portable : Newick est le plus répandu, mais sa grammaire compacte cache des conventions qu'il faut connaître. Il faut ensuite dessiner cet objet, joindre des métadonnées aux feuilles, choisir une échelle et des couleurs, puis exporter une figure que d'autres pourront reproduire. Ces opérations paraissent artisanales ; elles sont en réalité un pipeline de données, avec des points de contrôle et des pièges de lecture.

Cette section traite de la visualisation d'arbres déjà construits, pas de l'inférence : lire, annoter et publier un arbre sans surinterpréter. Le jeu de démonstration est synthétique ; il vérifie le parser et l'annotation, sans conclure sur une histoire évolutive réelle.

Théorie

Newick : une grammaire minimale

Le format Newick représente un arbre par des parenthèses et des virgules. Les parenthèses délimitent un groupe de descendants, les virgules séparent les enfants, et le point-virgule termine l'arbre. Une feuille est un nom ; un nœud interne est un groupe entre parenthèses. La chaîne suivante décrit deux paires de taxons :

((taxon_A:0.1,taxon_B:0.2)95:0.3,(taxon_C:0.15,taxon_D:0.25)80:0.4);

Le deux-points introduit une longueur de branche, exprimée en substitutions par site. taxon_A:0.1 signifie que la branche terminale de taxon_A mesure 0,1 substitution par site. Le nombre placé juste après une parenthèse fermante, ici 95 et 80, est un support associé à la branche qui mène au groupe. Il n'a pas d'unité biologique : c'est une proportion ou un pourcentage, selon la méthode qui l'a produit. Le point-virgule final n'est pas décoratif ; il marque la fin de l'enregistrement et permet de détecter une chaîne tronquée.

Newick ne code pas la position de la racine comme un objet distinct. La chaîne décrit une hiérarchie de groupes, et l'on peut choisir de la lire comme un arbre enraciné ou comme la représentation d'un arbre non enraciné. Les enfants d'un nœud peuvent être échangés sans changer la topologie : faire tourner un nœud revient à changer l'ordre de lecture, pas l'histoire évolutive. Cette liberté explique pourquoi deux figures d'apparence différente peuvent représenter le même arbre.

Le format complet autorise commentaires, noms entre guillemets, étiquettes internes et longueurs sur la racine. Le parser de cette section couvre un sous-ensemble simple : un seul arbre, des noms sans caractère réservé, des supports numériques et un point-virgule final. Il suffit aux arbres du cours et rend les erreurs faciles à diagnostiquer.

Exemple travaillé : distances et horloge

Reprenons l'arbre ci-dessus. Il contient quatre feuilles, trois nœuds internes et six branches. La distance entre deux feuilles est la somme des longueurs le long du chemin qui les relie. Ainsi,

d(\text{taxon\_A},\text{taxon\_B}) = 0{,}1 + 0{,}2 = 0{,}3

d(\text{taxon\_C},\text{taxon\_D}) = 0{,}15 + 0{,}25 = 0{,}4.

Pour aller de taxon_A à taxon_C, il faut remonter la branche de 0,1, traverser la branche interne de 0,3, redescendre la branche interne de 0,4, puis la branche terminale de 0,15 :

d(\text{taxon\_A},\text{taxon\_C}) = 0{,}1 + 0{,}3 + 0{,}4 + 0{,}15 = 0{,}95.

Les distances de la racine aux feuilles valent 0,4 pour A, 0,5 pour B, 0,55 pour C et 0,65 pour D. Elles ne sont pas égales : l'arbre n'est pas ultramétrique et ne vérifie pas une horloge stricte. Le dessiner comme un chronogramme serait une erreur ; un phylogramme est la représentation correcte.

Enraciner, ce n'est pas dessiner

Un arbre non enraciné décrit des proximités et des bipartitions ; il ne dit pas dans quel sens le temps s'écoule. Enraciner consiste à choisir une origine. Cette opération ajoute un nœud de degré deux et coupe une branche, sans changer les distances entre feuilles ni les bipartitions internes. Elle change l'interprétation : un groupe devient ancestral ou dérivé.

Trois stratégies sont courantes. L'enracinement par groupe externe (outgroup) place la racine sur la branche qui sépare un taxon ou un groupe de référence du reste de l'arbre. L'enracinement par point milieu (midpoint rooting) suppose une horloge approximative et place la racine au milieu de la plus longue distance entre deux feuilles. L'enracinement arbitraire, fréquent en sortie de Neighbor-Joining ou de certaines méthodes de vraisemblance, choisit une branche sans justification biologique. Les deux premières sont des hypothèses ; la troisième est une convention de dessin.

La racine visible n'est donc pas nécessairement biologique. Sans groupe externe ni horloge testée, sa position doit être présentée comme arbitraire. Pour un arbre non enraciné, mieux vaut souvent une représentation radiale, ou une légende qui précise la convention.

Supports : bootstrap et probabilités postérieures

Le support d'une branche mesure la confiance dans la bipartition qu'elle définit. Le support bootstrap, noté de 0 à 100 ou de 0 à 1, est la proportion de réplicats — obtenus en rééchantillonnant les colonnes — qui contiennent la bipartition. Il dépend de l'alignement, du nombre de taxons, du modèle et de la méthode. Ce n'est pas la probabilité que le groupe soit vrai.

La probabilité postérieure, notée de 0 à 1, vient d'une analyse bayésienne. Elle résume la probabilité du groupe conditionnellement aux données, au modèle et à la loi a priori. Elle est souvent plus élevée que le bootstrap, et les deux valeurs ne sont pas interchangeables. Un 95 après une parenthèse peut donc signifier 95 % de réplicats bootstrap ou 0,95 de probabilité postérieure, selon l'outil et le fichier. Il faut lire l'échelle avant de comparer.

Une branche sans valeur n'est pas une branche de support nul : le support peut être absent du fichier, masqué, ou la branche non résolue. Un support élevé ne garantit pas non plus la topologie ; il indique une stabilité sous le modèle utilisé. Les seuils de 70 ou de 0,95 sont des conventions de lecture, pas des tests universels.

Choisir une mise en page

Trois familles de figures répondent à trois questions différentes. Le cladogramme ne montre que la topologie : les branches ont toutes la même longueur et l'on ne peut pas lire de distance évolutive. Le phylogramme respecte les longueurs de branches et permet de comparer des rythmes d'évolution. Le chronogramme impose une échelle de temps et suppose une horloge calibrée ; il ne se déduit pas d'un simple phylogramme.

La disposition rectangulaire place les feuilles sur une colonne et se lit de gauche à droite ; elle reste lisible pour quelques dizaines de taxons. La disposition circulaire répartit les feuilles autour d'un cercle et gagne de la place pour les grands arbres, au prix d'une lecture moins intuitive. La disposition radiale en est une variante. Au-delà de plusieurs milliers de feuilles, il faut prévoir le repli des étiquettes, la recherche et le zoom.

Une échelle de longueur de branches est indispensable sur un phylogramme. Sans elle, le lecteur ne sait pas si une branche deux fois plus longue représente deux fois plus de substitutions ou un simple effet de dessin. La barre d'échelle indique une longueur, par exemple 0,1 substitution par site, et doit être dessinée dans la même unité que les branches. Sur un cladogramme, l'échelle de longueur n'a pas de sens ; en revanche, l'échelle des supports doit être expliquée.

Figure 5.5.1. Schéma du phylogramme attendu pour demo.nwk : les clades (A,B) et (C,D) portent des supports 95 et 80, les feuilles sont colorées selon le groupe et une barre d'échelle indique 0,1 substitution par site. Schéma non à l'échelle.

Annoter par métadonnées

Une annotation est une information attachée à une feuille ou à une branche : groupe écologique, hôte, température, présence d'un gène, expression. La règle de base est de joindre les métadonnées par le nom exact de la feuille, jamais par sa position. Un tableau avec une colonne tip se vérifie en comptant les feuilles sans métadonnées, les clés sans feuille et les doublons.

Les cartes de couleurs doivent être choisies selon le type de variable. Pour une variable catégorielle, une palette discrète, stable et accessible, avec une légende explicite. Pour une variable continue, une échelle graduée et une légende avec ses bornes. Éviter de coder une information par la seule couleur : ajouter une forme, un texte ou une position. Les daltoniens représentent une part importante du lectorat, et une figure en noir et blanc doit rester lisible.

FigTree importe un Newick, affiche supports et longueurs, et exporte en PDF ou SVG. iTOL propose des pistes de couleurs, des histogrammes et un rendu circulaire dans le navigateur. ETE construit la figure par programme et rejoue le script. Le choix dépend du nombre de taxons, de l'interactivité et de la reproductibilité attendue.

Reproductibilité et passage à l'échelle

Une figure reproductible repose sur une chaîne explicite : Newick, tableau de métadonnées, script ou commandes, versions, paramètres et format de sortie. Couleurs, ordre des feuilles, racine et échelle des supports doivent être documentés ; une retouche manuelle doit être décrite et le fichier source conservé.

Le coût computationnel est modeste à l'échelle d'un cours. Le parsing est linéaire en nombre de caractères, le calcul de la mise en page est linéaire en nombre de nœuds, et le rendu l'est aussi. La jointure des métadonnées se fait en temps moyen constant par feuille avec une table de hachage, soit $O(n)$ pour $n$ feuilles. Le vrai goulot d'étranglement est la lisibilité : au-delà de quelques centaines de feuilles, les étiquettes se chevauchent et la figure doit être découpée, rendue en circulaire ou accompagnée d'un fichier de recherche.

Un SVG ou un PDF conserve la netteté et reste éditable ; un PNG de faible résolution ne convient pas pour une publication. La légende doit indiquer la méthode de construction, le modèle, le support, la racine et la source des métadonnées. Sans ces informations, la figure n'est pas reproductible.

Implémentation

Le code suivant est une version compacte et autonome du parser, de l'extraction des feuilles, de l'annotation et de l'export. Il ne dépend que de la bibliothèque standard ; les exercices ajoutent les contrôles de type et le refus des doublons.

Parser, annoter et réécrire un arbre Newick

from copy import deepcopy
from math import isfinite

class _Parser:
  def __init__(self, text):
      self.text = text
      self.pos = 0

def skip_ws(self):
      while self.pos < len(self.text) and self.text[self.pos].isspace():
          self.pos += 1

def peek(self):
      self.skip_ws()
      return self.text[self.pos] if self.pos < len(self.text) else ""

def number(self):
      self.skip_ws()
      start = self.pos
      if self.pos < len(self.text) and self.text[self.pos] in "+-":
          self.pos += 1
      digits = 0
      while self.pos < len(self.text) and self.text[self.pos].isdigit():
          self.pos += 1
          digits += 1
      if self.pos < len(self.text) and self.text[self.pos] == ".":
          self.pos += 1
          while self.pos < len(self.text) and self.text[self.pos].isdigit():
              self.pos += 1
              digits += 1
      if digits == 0:
          raise ValueError("expected a number")
      value = float(self.text[start:self.pos])
      if not isfinite(value) or value < 0:
          raise ValueError("invalid length or support")
      return value

def label(self):
      self.skip_ws()
      start = self.pos
      while self.pos < len(self.text) and self.text[self.pos] not in "(),:;":
          if self.text[self.pos].isspace():
              break
          self.pos += 1
      label = self.text[start:self.pos]
      if not label:
          raise ValueError("empty label")
      return label

def node(self):
      if self.peek() == "(":
          self.pos += 1
          children = [self.node()]
          while self.peek() == ",":
              self.pos += 1
              children.append(self.node())
          if self.peek() != ")":
              raise ValueError("missing closing parenthesis")
          self.pos += 1
          support = None
          if self.peek() not in (":", ",", ")", ";"):
              support = self.number()
          length = None
          if self.peek() == ":":
              self.pos += 1
              length = self.number()
          return {
              "name": None,
              "length": length,
              "support": support,
              "children": children,
          }
      name = self.label()
      length = None
      if self.peek() == ":":
          self.pos += 1
          length = self.number()
      return {"name": name, "length": length, "support": None, "children": []}

def parse_newick(text):
  parser = _Parser(text)
  tree = parser.node()
  if parser.peek() != ";":
      raise ValueError("missing semicolon")
  parser.pos += 1
  parser.skip_ws()
  if parser.pos != len(text):
      raise ValueError("trailing characters")
  return tree

def leaf_names(tree):
  names = []

def walk(node):
      if not node["children"]:
          names.append(node["name"])
      else:
          for child in node["children"]:
              walk(child)

walk(tree)
  return names

def annotate_tips(tree, metadata):
  annotated = deepcopy(tree)

def walk(node):
      if not node["children"]:
          node["metadata"] = dict(metadata.get(node["name"], {}))
      else:
          for child in node["children"]:
              walk(child)

walk(annotated)
  return annotated

def format_number(value):
  text = f"{value:.4f}".rstrip("0").rstrip(".")
  return text if text else "0"

def to_newick(tree):
  def render(node):
      if not node["children"]:
          text = node["name"]
      else:
          text = "(" + ",".join(render(child) for child in node["children"]) + ")"
          if node["support"] is not None:
              text += format_number(node["support"])
      if node["length"] is not None:
          text += ":" + format_number(node["length"])
      return text

return render(tree) + ";"

demo = "((taxon_A:0.1,taxon_B:0.2)95:0.3,(taxon_C:0.15,taxon_D:0.25)80:0.4);"
tree = parse_newick(demo)
print(leaf_names(tree))
metadata = {
  "taxon_A": {"group": "alpha", "color": "#1f77b4"},
  "taxon_B": {"group": "beta", "color": "#ff7f0e"},
  "taxon_C": {"group": "alpha", "color": "#1f77b4"},
  "taxon_D": {"group": "beta", "color": "#ff7f0e"},
}
annotated = annotate_tips(tree, metadata)
print(to_newick(annotated))
print(annotated["children"][0]["children"][0]["metadata"])

SortieCtrl+Entrée pour exécuter · 10 s max

Aucune sortie. Exécutez le code pour voir le résultat.

Le code s'exécute dans votre navigateur (Web Worker isolé). Il n'a pas accès au serveur ; l'accès réseau est désactivé pendant l'exécution. Le premier clic sur « Exécuter » télécharge Pyodide depuis jsDelivr (plusieurs mégaoctets, version 0.26.4 épinglée) ; rien n'est chargé avant ce clic.

La sortie vérifiée le 2026-11-01 avec Python 3.13 est :

['taxon_A', 'taxon_B', 'taxon_C', 'taxon_D']
((taxon_A:0.1,taxon_B:0.2)95:0.3,(taxon_C:0.15,taxon_D:0.25)80:0.4);
{'group': 'alpha', 'color': '#1f77b4'}

Trois points sont critiques. Le support se lit après la parenthèse et avant le deux-points : )95:0.3 associe 95 au clade et 0,3 à la branche. L'annotation ne modifie pas le Newick : les métadonnées restent séparées de la topologie. L'export arrondit les nombres mais ne convertit jamais l'échelle d'un support.

Les trois outils partent du même fichier. FigTree 1.4.4 ouvre un Newick et exporte la figure ; iTOL accepte un Newick et un tableau d'annotations ; ETE 4.x génère les figures depuis Python. Conservez toujours le Newick, le tableau et le script : la figure n'est qu'une sortie.

Étude de cas

Exemple synthétique. Le fichier datasets/phylogeny/demo.nwk contient un arbre de quatre taxons, créé pour ce cours. Il ne représente aucune espèce réelle. Il rend visibles la topologie, les supports et les longueurs de branches en une seule ligne.

La question est simple : peut-on parser cet arbre, annoter ses feuilles avec un tableau synthétique et décrire une figure lisible sans prétendre produire une capture réelle ? Nous procédons en cinq étapes.

Lire demo.nwk et vérifier qu'il contient un seul arbre terminé par un point-virgule.
Parser la chaîne avec parse_newick, puis extraire l'ordre des feuilles avec leaf_names.
Construire un tableau de métadonnées synthétique avec les colonnes group et color, une ligne par feuille.
Annoter l'arbre avec annotate_tips, puis exporter la version normalisée avec to_newick.
Ouvrir le Newick dans FigTree, iTOL ou ETE et décrire la figure attendue, sans capture inventée.

Le tableau utilisé est le suivant. Les valeurs sont inventées pour l'exercice ; elles ne décrivent aucun organisme.

tip       group   color
taxon_A   alpha   #1f77b4
taxon_B   beta    #ff7f0e
taxon_C   alpha   #1f77b4
taxon_D   beta    #ff7f0e

Le parser retrouve les quatre feuilles dans l'ordre taxon_A, taxon_B, taxon_C, taxon_D. Les supports valent 95 pour (A,B) et 80 pour (C,D). L'export normalisé redonne la chaîne d'entrée : le round-trip est vérifié. L'annotation couvre 4 feuilles sur 4, sans clé inutilisée, et le rapport renvoie un statut ok avec une échelle bootstrap.

La figure attendue est un phylogramme rectangulaire, décrit ici comme sortie illustrative : aucune capture n'a été fabriquée. Les feuilles sont alignées à droite, les branches à l'échelle, et les clades (A,B) et (C,D) portent les supports 95 et 80. A et C sont en bleu (alpha), B et D en orange (beta). Une légende et une barre d'échelle de 0,1 substitution par site complètent la figure. La racine est celle du fichier ; faute de groupe externe, sa position est conventionnelle et doit être signalée.

La figure ne prouve pas que le groupe alpha est monophylétique : le trait est distribué sur deux branches. Selon l'état ancestral, il faudrait deux acquisitions ou une perte. Tester cette hypothèse exigerait un échantillonnage plus large et un modèle de caractère. L'arbre synthétique vérifie la chaîne de visualisation, pas la biologie.

Un arbre circulaire serait possible, mais inutile pour quatre feuilles. Il devient pertinent pour plusieurs centaines de taxons, avec une légende, un zoom et une correspondance entre identifiants courts et noms complets. La disposition doit servir la question, pas décorer.

Erreurs fréquentes

Quiz

Exercices

Exercice guidé5.5-e1

Énoncé

Écrire parse_newick(text) qui lit un arbre Newick simple et renvoie sa racine sous forme de dictionnaire imbriqué, puis leaf_names(tree) qui renvoie les feuilles dans l'ordre de parcours. Accepter longueurs et supports facultatifs, espaces autour des jetons et un point-virgule final. Refuser une chaîne vide, un point-virgule manquant, des parenthèses déséquilibrées, une longueur négative, une étiquette vide et des doublons. leaf_names refuse un nœud à moins de deux enfants et une feuille sans nom.

Comment vérifier votre travail

Les tests se trouvent dans exercises/module-5/5.5-visualisation-arbres/test_5_5.py. Depuis la racine du dépôt :

python -m pytest exercises/module-5/5.5-visualisation-arbres -q

Corrigé verrouillé

Le corrigé est chargé uniquement après confirmation. Il n'est pas présent dans la page avant cette action.

Exercice approfondi5.5-e2

Énoncé

Écrire annotate_tips(tree, metadata) qui renvoie une copie de l'arbre avec un dictionnaire de métadonnées sur chaque feuille, puis to_newick(tree, digits=4) qui sérialise l'arbre. Une feuille absente reçoit un dictionnaire vide ; une clé sans feuille est ignorée ; l'arbre d'origine reste intact. L'export conserve supports et longueurs, arrondit à digits décimales et se termine par un point-virgule. Refuser un support sur une feuille, un nom incompatible avec le Newick simple et des métadonnées mal typées.

Comment vérifier votre travail

Les tests se trouvent dans exercises/module-5/5.5-visualisation-arbres/test_5_5.py. Depuis la racine du dépôt :

python -m pytest exercises/module-5/5.5-visualisation-arbres -q

Corrigé verrouillé

Le corrigé est chargé uniquement après confirmation. Il n'est pas présent dans la page avant cette action.

Mini-projet5.5-projet

Énoncé

Mini-projet : rapport d'annotation. Écrire tree_annotation_report(newick, metadata) qui parse un arbre, vérifie la couverture des métadonnées, interprète l'échelle des supports et exporte un Newick normalisé. Le rapport contient le nombre de feuilles, de nœuds internes et de branches, le degré de la racine, l'ordre des feuilles, les feuilles annotées, les métadonnées manquantes ou inutilisées, les supports et leur échelle (none, probability, bootstrap, mixed), leurs bornes, des avertissements et un statut. Refuser un Newick mal formé, moins de deux feuilles, des doublons et des métadonnées mal typées. Signaler sans exception les feuilles non annotées, les clés orphelines, l'absence de supports, les supports faibles et les branches sans longueur.

Comment vérifier votre travail

Les tests se trouvent dans exercises/module-5/5.5-visualisation-arbres/projet/test_projet_5_5.py. Depuis la racine du dépôt :

python -m pytest exercises/module-5/5.5-visualisation-arbres/projet -q

Corrigé verrouillé

Le corrigé est chargé uniquement après confirmation. Il n'est pas présent dans la page avant cette action.

Résumé

Newick encode la topologie avec des parenthèses, des virgules et un point-virgule ; les longueurs suivent : et les supports suivent ).
Un arbre non enraciné ne dit pas dans quel sens le temps s'écoule ; la racine dessinée est une hypothèse ou une convention.
Un support bootstrap et une probabilité postérieure ne partagent ni la définition, ni l'échelle, ni les seuils de lecture.
Une branche sans valeur n'est pas une branche certaine : le support peut être absent, masqué ou non résolu.
Le cladogramme montre la topologie, le phylogramme les distances, le chronogramme le temps ; chaque figure exige une échelle et une légende.
Les métadonnées se joignent par nom exact de feuille, avec contrôle des doublons, des feuilles non annotées et des clés orphelines.
Une figure reproductible conserve le Newick, le tableau, le script, les versions, les paramètres et une légende complète.

Références

FigTree, documentation officielle. https://tree.bio.ed.ac.uk/software/figtree/
Letunic, I. et Bork, P. (2021). Interactive Tree Of Life (iTOL) v5: an online tool for phylogenetic tree display and annotation. Nucleic Acids Research, 49(W1), W293–W296.
Huerta-Cepas, J., Serra, F. et Bork, P. (2016). ETE 3: Reconstruction, analysis and visualization of phylogenomic data. Molecular Biology and Evolution, 33(6), 1635–1638.
Felsenstein, J. (2004). Inferring Phylogenies. Sinauer Associates.
Documentation iTOL. https://itol.embl.de/help.cgi
Documentation ETE. http://etetoolkit.org/docs/latest/