filogenética

¿Qué hace filogenética?

Resumen

El análisis filogenético reconstruye la historia evolutiva de secuencias biológicas (genes, proteínas, genomas) infiriendo el patrón de ramificación del descenso. Esta habilidad cubre el pipeline estándar:

1. MAFFT — Alineamiento múltiple de secuencias
2. IQ-TREE 2 — Inferencia de árboles por máxima verosimilitud con selección de modelos
3. FastTree — Máxima verosimilitud aproximada rápida (para conjuntos grandes)
4. ETE3 — Biblioteca de Python para manipulación y visualización de árboles

Instalación:

# Conda (recomendado para herramientas CLI)
conda install -c bioconda mafft iqtree fasttree
uv pip install ete3

# La representación de TreeStyle/NodeStyle de ete3 utiliza su backend Qt, por lo que la salida de imágenes
# también necesita PyQt5; el análisis de árboles y las estadísticas funcionan sin él.
uv pip install PyQt5

Cuándo usar esta habilidad

Usa filogenética cuando:

• Relaciones evolutivas: ¿Qué organismo/gen está más estrechamente relacionado con mi secuencia?
• Filodinámica viral: Traza la propagación de brotes y estima las fechas de transmisión
• Análisis de familias de proteínas: Infiere relaciones evolutivas dentro de una familia génica
• Detección de transferencia horizontal de genes: Identifica genes con árboles de genes/especies discordantes
• Reconstrucción de secuencias ancestrales: Infiere secuencias proteicas ancestrales
• Análisis de reloj molecular: Estima fechas de divergencia utilizando muestreo temporal
• Complemento de GWAS: Coloca variantes en contexto evolutivo (ej., variantes de SARS-CoV-2)
• Microbiología: Filogenia de especies a partir de ARNr 16S o filogenia del genoma central

Flujo de trabajo estándar

1. Alineamiento múltiple de secuencias con MAFFT

import subprocess
import os

def run_mafft(input_fasta: str, output_fasta: str, method: str = "auto",
               n_threads: int = 4) -> str:
    """
    Alinea secuencias con MAFFT.

    Args:
        input_fasta: Ruta al archivo FASTA sin alinear
        output_fasta: Ruta para la salida alineada
        method: 'auto' (selección automática), 'einsi' (preciso), 'linsi' (preciso, lento),
                'fftnsi' (medio), 'fftns' (rápido), 'retree2' (rápido)
        n_threads: Número de hilos de CPU

    Returns:
        Ruta al archivo FASTA alineado
    """
    methods = {
        "auto": ["mafft", "--auto"],
        "einsi": ["mafft", "--genafpair", "--maxiterate", "1000"],
        "linsi": ["mafft", "--localpair", "--maxiterate", "1000"],
        "fftnsi": ["mafft", "--fftnsi"],
        "fftns": ["mafft", "--fftns"],
        "retree2": ["mafft", "--retree", "2"],
    }

    cmd = methods.get(method, methods["auto"])
    cmd += ["--thread", str(n_threads), "--inputorder", input_fasta]

    with open(output_fasta, 'w') as out:
        result = subprocess.run(cmd, stdout=out, stderr=subprocess.PIPE, text=True)

    if result.returncode != 0:
        raise RuntimeError(f"MAFFT falló:\n{result.stderr}")

    # Contar secuencias alineadas
    with open(output_fasta) as f:
        n_seqs = sum(1 for line in f if line.startswith('>'))
    print(f"MAFFT: alineadas {n_seqs} secuencias → {output_fasta}")

    return output_fasta

# Guía de selección del método MAFFT:
# Pocas secuencias (<200), precisión: linsi o einsi
# Muchas secuencias (<1000), moderado: fftnsi
# Conjuntos grandes (>1000): fftns o auto
# Ultra-rápido (>10000): mafft --retree 1

2. Recortar alineamiento (Opcional pero recomendado)

def trim_alignment_trimal(aligned_fasta: str, output_fasta: str,
                            method: str = "automated1") -> str:
    """
    Recorta columnas mal alineadas con TrimAl.

    Métodos:
    - 'automated1': Heurística automática (recomendado)
    - 'gappyout': Elimina columnas con gaps
    - 'strict': Umbral de gap estricto
    """
    cmd = ["trimal", f"-{method}", "-in", aligned_fasta, "-out", output_fasta, "-fasta"]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"Advertencia de TrimAl: {result.stderr}")
        # Devolverse al alineamiento sin recortar
        import shutil
        shutil.copy(aligned_fasta, output_fasta)
    return output_fasta

3. IQ-TREE 2 — Árbol de máxima verosimilitud

def run_iqtree(aligned_fasta: str, output_prefix: str,
                model: str = "TEST", bootstrap: int = 1000,
                n_threads: int = 4, extra_args: list = None) -> dict:
    """
    Construye un árbol de máxima verosimilitud con IQ-TREE 2.

    Args:
        aligned_fasta: Archivo FASTA alineado
        output_prefix: Prefijo para los archivos de salida
        model: 'TEST' para selección automática de modelo, o especificar (ej., 'GTR+G' para ADN,
               'LG+G4' para proteínas, 'JTT+G' para proteínas)
        bootstrap: Número de réplicas de bootstrap ultrarrápido (1000 recomendado)
        n_threads: Número de hilos ('AUTO' para detección automática)
        extra_args: Argumentos adicionales para IQ-TREE

    Returns:
        Dict con rutas a los archivos de salida
    """
    cmd = [
        "iqtree2",
        "-s", aligned_fasta,
        "--prefix", output_prefix,
        "-m", model,
        "-B", str(bootstrap),   # Bootstrap ultrarrápido
        "-T", str(n_threads),
        "--redo"                # Sobrescribir resultados existentes
    ]

    if extra_args:
        cmd.extend(extra_args)

    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        raise RuntimeError(f"IQ-TREE falló:\n{result.stderr}")

    # Imprimir resultado de selección de modelo
    log_file = f"{output_prefix}.log"
    if os.path.exists(log_file):
        with open(log_file) as f:
            for line in f:
                if "Best-fit model" in line:
                    print(f"IQ-TREE: {line.strip()}")

    output_files = {
        "tree": f"{output_prefix}.treefile",
        "log": f"{output_prefix}.log",
        "iqtree": f"{output_prefix}.iqtree",  # Informe completo
        "model": f"{output_prefix}.model.gz",
    }

    print(f"IQ-TREE: Árbol guardado en {output_files['tree']}")
    return output_files

# Guía de selección de modelo IQ-TREE:
# ADN:      TEST → GTR+G, HKY+G, TrN+G
# Proteína: TEST → LG+G4, WAG+G, JTT+G, Q.pfam+G
# Codón:    TEST → MG+F3X4

# Para análisis temporal (reloj molecular), añadir:
# extra_args = ["--date", "dates.txt", "--clock-test", "--date-CI", "95"]

4. FastTree — ML aproximado rápido

Para conjuntos grandes (>1000 secuencias) donde IQ-TREE es demasiado lento:

def run_fasttree(aligned_fasta: str, output_tree: str,
                  sequence_type: str = "nt", model: str = "gtr",
                  n_threads: int = 4) -> str:
    """
    Construye un árbol ML aproximado rápido con FastTree.

    Args:
        sequence_type: 'nt' para nucleótidos o 'aa' para aminoácidos
        model: Para nt: 'gtr' (recomendado) o 'jc'; para aa: 'lg', 'wag', 'jtt'
    """
    if sequence_type == "nt":
        cmd = ["FastTree", "-nt", "-gtr"]
    else:
        cmd = ["FastTree", f"-{model}"]

    cmd += [aligned_fasta]

    with open(output_tree, 'w') as out:
        result = subprocess.run(cmd, stdout=out, stderr=subprocess.PIPE, text=True)

    if result.returncode != 0:
        raise RuntimeError(f"FastTree falló:\n{result.stderr}")

    print(f"FastTree: Árbol guardado en {output_tree}")
    return output_tree

5. Análisis y visualización de árboles con ETE3

from ete3 import Tree, TreeStyle, NodeStyle, TextFace, PhyloTree
import matplotlib.pyplot as plt

def load_tree(tree_file: str) -> Tree:
    """Cargar un archivo de árbol Newick."""
    t = Tree(tree_file)
    print(f"Árbol: {len(t)} hojas, {len(list(t.traverse()))} nodos")
    return t

def basic_tree_stats(t: Tree) -> dict:
    """Calcular estadísticas básicas del árbol."""
    leaves = t.get_leaves()
    distances = [t.get_distance(l1, l2) for l1 in leaves[:min(50, len(leaves))]
                 for l2 in leaves[:min(50, len(leaves))] if l1 != l2]

    stats = {
        "n_leaves": len(leaves),
        "n_internal_nodes": len(t) - len(leaves),
        "total_branch_length": sum(n.dist for n in t.traverse()),
        "max_leaf_distance": max(distances) if distances else 0,
        "mean_leaf_distance": sum(distances)/len(distances) if distances else 0,
    }
    return stats

def find_mrca(t: Tree, leaf_names: list) -> Tree:
    """Encontrar el ancestro común más reciente de un conjunto de hojas."""
    return t.get_common_ancestor(*leaf_names)

def visualize_tree(t: Tree, output_file: str = "tree.png",
                    show_branch_support: bool = True,
                    color_groups: dict = None,
                    width: int = 800) -> None:
    """
    Renderizar árbol filogenético a imagen.

    Args:
        t: Objeto Tree de ETE3
        color_groups: Dict que mapea nombre_hoja → color (para colorear taxa)
        show_branch_support: Mostrar valores de bootstrap
    """
    ts = TreeStyle()
    ts.show_leaf_name = True
    ts.show_branch_support = show_branch_support
    ts.mode = "r"  # 'r' = rectangular, 'c' = circular

    if color_groups:
        for node in t.traverse():
            if node.is_leaf() and node.name in color_groups:
                nstyle = NodeStyle()
                nstyle["fgcolor"] = color_groups[node.name]
                nstyle["size"] = 8
                node.set_style(nstyle)

    t.render(output_file, tree_style=ts, w=width, units="px")
    print(f"Árbol guardado en: {output_file}")

def midpoint_root(t: Tree) -> Tree:
    """Enraizar árbol en el punto medio (usar cuando se desconoce el grupo externo)."""
    t.set_outgroup(t.get_midpoint_outgroup())
    return t

def prune_tree(t: Tree, keep_leaves: list) -> Tree:
    """Podar el árbol para conservar solo las hojas especificadas."""
    t.prune(keep_leaves, preserve_branch_length=True)
    return t

6. Script de análisis completo

import subprocess, os
from ete3 import Tree

def full_phylogenetic_analysis(
    input_fasta: str,
    output_dir: str = "phylo_results",
    sequence_type: str = "nt",
    n_threads: int = 4,
    bootstrap: int = 1000,
    use_fasttree: bool = False
) -> dict:
    """
    Pipeline filogenético completo: alinear → recortar → árbol → visualizar.

    Args:
        input_fasta: FASTA sin alinear
        sequence_type: 'nt' (nucleótido) o 'aa' (aminoácido/proteína)
        use_fasttree: Usar FastTree en lugar de IQ-TREE (más rápido para conjuntos grandes)
    """
    os.makedirs(output_dir, exist_ok=True)
    prefix = os.path.join(output_dir, "phylo")

    print("=" * 50)
    print("Paso 1: Alineamiento múltiple de secuencias (MAFFT)")
    aligned = run_mafft(input_fasta, f"{prefix}_aligned.fasta",
                         method="auto", n_threads=n_threads)

    print("\nPaso 2: Inferencia del árbol")
    if use_fasttree:
        tree_file = run_fasttree(
            aligned, f"{prefix}.tree",
            sequence_type=sequence_type,
            model="gtr" if sequence_type == "nt" else "lg"
        )
    else:
        model = "TEST" if sequence_type == "nt" else "TEST"
        iqtree_files = run_iqtree(
            aligned, prefix,
            model=model,
            bootstrap=bootstrap,
            n_threads=n_threads
        )
        tree_file = iqtree_files["tree"]

    print("\nPaso 3: Análisis del árbol")
    t = Tree(tree_file)
    t = midpoint_root(t)

    stats = basic_tree_stats(t)
    print(f"Estadísticas del árbol: {stats}")

    print("\nPaso 4: Visualización")
    visualize_tree(t, f"{prefix}_tree.png", show_branch_support=True)

    # Guardar árbol enraizado
    rooted_tree_file = f"{prefix}_rooted.nwk"
    t.write(format=1, outfile=rooted_tree_file)

    results = {
        "aligned_fasta": aligned,
        "tree_file": tree_file,
        "rooted_tree": rooted_tree_file,
        "visualization": f"{prefix}_tree.png",
        "stats": stats
    }

    print("\n" + "=" * 50)
    print("¡Análisis filogenético completado!")
    print(f"Resultados en: {output_dir}/")
    return results

Guía de modelos de IQ-TREE

Modelos de ADN

Modelo	Descripción	Caso de uso
GTR+G4	General Time Reversible + Gamma	Modelo de ADN más flexible
HKY+G4	Hasegawa-Kishino-Yano + Gamma	Modelo de dos tasas (común)
TrN+G4	Tamura-Nei	Transiciones desiguales
JC	Jukes-Cantor	Más simple; todas las tasas iguales

Modelos de proteínas

Modelo	Descripción	Caso de uso
LG+G4	Le-Gascuel + Gamma	Mejor modelo de proteína promedio
WAG+G4	Whelan-Goldman	Ampliamente usado
JTT+G4	Jones-Taylor-Thornton	Modelo clásico
Q.pfam+G4	Entrenado en pfam	Para familias de proteínas similares a Pfam
Q.bird+G4	Específico de aves	Proteínas de vertebrados

Consejo: Usa -m TEST para que IQ-TREE seleccione automáticamente el mejor modelo.

Mejores prácticas

• Calidad del alineamiento primero: Alineamiento pobre → árboles poco fiables; revisa el alineamiento manualmente
• Usa linsi para conjuntos pequeños (<200 seq), fftns o auto para alineamientos grandes
• Selección de modelos: Siempre usa -m TEST para IQ-TREE a menos que tengas una razón específica
• Bootstrap: Usa ≥1000 bootstraps ultrarrápidos (-B 1000) para soporte de ramas
• Enraizar el árbol: Los árboles sin raíz pueden ser engañosos; usa un grupo externo o enraizamiento por punto medio
• FastTree para >5000 secuencias: IQ-TREE se vuelve lento; FastTree es 10–100× más rápido
• Recortar alineamientos largos: TrimAl elimina columnas poco fiables; mejora la precisión del árbol
• Verificar recombinación en secuencias virales/bacterianas antes de construir árboles (RDP4, GARD)

Recursos adicionales

• MAFFT: https://mafft.cbrc.jp/alignment/software/
• IQ-TREE 2: http://www.iqtree.org/ | Tutorial: https://www.iqtree.org/workshop/molevol2022
• FastTree: http://www.microbesonline.org/fasttree/
• ETE3: http://etetoolkit.org/
• FigTree (visualización GUI): https://tree.bio.ed.ac.uk/software/figtree/
• iTOL (visualización web): https://itol.embl.de/
• MUSCLE (alineador alternativo): https://www.drive5.com/muscle/
• TrimAl (recorte de alineamiento): https://vicfero.github.io/trimal/