scripts/05_ml_and_network_analysis.py

import os
import json
import requests
import numpy as np
import pandas as pd
from scipy.stats import spearmanr
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern, ConstantKernel
from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
from sklearn.preprocessing import StandardScaler
import networkx as nx

RESULTS_DIR = "results"
STRING_API = "https://string-db.org/api/json/network"
TAXON_ID = 4932
STRING_SCORE_THRESHOLD = 400

DRUG_EFFLUX_GENES = {
    "PDR5", "PDR10", "PDR11", "PDR12", "PDR15", "PDR18", "SNQ2", "YOR1", "YCF1"
}


def load_correlation_df():
    path = os.path.join(RESULTS_DIR, "stress_element_nem_correlation.csv")
    if not os.path.exists(path):
        raise FileNotFoundError(f"{path} not found. Run 03_stress_element_analysis.py first.")
    return pd.read_csv(path)


def build_window_features(abc_sequences, nem_results, stress_results,
                          window_size=100, step_size=50):
    from collections import Counter
    rows = []
    for gene, seqs in abc_sequences.items():
        prom = seqs["promoter"]
        plen = len(prom)
        prom_nem_positions = {n["position"] for n in nem_results.get(gene, {}).get("promoter", [])}
        gene_stress = stress_results.get(gene, {})
        for start in range(0, plen - window_size, step_size):
            window = prom[start:start + window_size]
            gc = (window.count("G") + window.count("C")) / window_size
            cg = window.count("CG") / (window_size - 1) if window_size > 1 else 0
            counts = Counter(window)
            entropy = -sum((c / window_size) * np.log2(c / window_size)
                           for c in counts.values() if c > 0)
            homo = max(len(max(window.split(b), key=len)) for b in "ACGT")
            rows.append({
                "gene": gene, "start": start,
                "gc_content": gc, "at_content": 1 - gc, "cg_dinuc": cg,
                "entropy": entropy, "homopolymer_max": homo,
                "stre_count": sum(1 for e in gene_stress.get("STRE", [])
                                  if start <= e["position"] < start + window_size),
                "pdre_count": sum(1 for e in gene_stress.get("PDRE", [])
                                  if start <= e["position"] < start + window_size),
                "hse_count": sum(1 for e in gene_stress.get("HSE", [])
                                 if start <= e["position"] < start + window_size),
                "ap1_count": sum(1 for e in gene_stress.get("AP1", [])
                                 if start <= e["position"] < start + window_size),
                "distance_tss": plen - start,
                "nem_count": sum(1 for p in prom_nem_positions
                                 if start <= p < start + window_size),
            })
    return pd.DataFrame(rows)


def run_random_forest(ml_df):
    feature_cols = [
        "gc_content", "at_content", "cg_dinuc", "entropy",
        "homopolymer_max", "stre_count", "pdre_count",
        "hse_count", "ap1_count", "distance_tss",
    ]
    genes = ml_df["gene"].unique()
    n_test = max(1, len(genes) // 5)
    np.random.seed(42)
    test_genes = set(np.random.choice(genes, size=n_test, replace=False))
    train_df = ml_df[~ml_df["gene"].isin(test_genes)]
    test_df = ml_df[ml_df["gene"].isin(test_genes)]

    X_train, y_train = train_df[feature_cols].values, train_df["nem_count"].values
    X_test, y_test = test_df[feature_cols].values, test_df["nem_count"].values

    rf = RandomForestRegressor(n_estimators=200, random_state=42, n_jobs=-1)
    rf.fit(X_train, y_train)
    y_pred = rf.predict(X_test)

    cv_scores = cross_val_score(rf, ml_df[feature_cols].values,
                                ml_df["nem_count"].values, cv=5, scoring="r2")

    importance_df = pd.DataFrame({
        "feature": feature_cols,
        "importance": rf.feature_importances_,
    }).sort_values("importance", ascending=False)

    perf = {
        "test_r2": round(float(r2_score(y_test, y_pred)), 3),
        "test_rmse": round(float(np.sqrt(mean_squared_error(y_test, y_pred))), 3),
        "test_mae": round(float(mean_absolute_error(y_test, y_pred)), 3),
        "cv_r2_mean": round(float(cv_scores.mean()), 3),
        "cv_r2_std": round(float(cv_scores.std()), 3),
        "n_train_windows": int(len(train_df)),
        "n_test_windows": int(len(test_df)),
    }
    return importance_df, perf


def run_gp_landscape(corr_df):
    X = corr_df[["PDRE", "total_stress_elements"]].values
    y = corr_df["nem_density_per_kb"].values
    X_scaled = StandardScaler().fit_transform(X)
    gp = GaussianProcessRegressor(
        kernel=ConstantKernel(1.0) * Matern(nu=1.5),
        n_restarts_optimizer=5, random_state=42
    )
    gp.fit(X_scaled, y)
    y_pred = gp.predict(X_scaled)
    return {
        "gp_r2": round(float(r2_score(y, y_pred)), 3),
        "gp_rmse": round(float(np.sqrt(mean_squared_error(y, y_pred))), 1),
        "gp_mae": round(float(mean_absolute_error(y, y_pred)), 1),
    }


def fetch_string_interactions(genes):
    params = {
        "identifiers": "%0d".join(genes),
        "species": TAXON_ID,
        "required_score": STRING_SCORE_THRESHOLD,
        "network_type": "physical",
        "caller_identity": "nullomer_study",
    }
    try:
        r = requests.get(STRING_API, params=params, timeout=60)
        if r.status_code == 200:
            return [
                {"gene_a": d["preferredName_A"], "gene_b": d["preferredName_B"], "score": d["score"]}
                for d in r.json()
                if d["preferredName_A"] in genes and d["preferredName_B"] in genes
            ]
    except Exception:
        pass
    return []


def build_network(genes, interactions, nem_map):
    G = nx.Graph()
    for gene in genes:
        G.add_node(gene, nem_density=nem_map.get(gene, 0))
    for inter in interactions:
        if inter["gene_a"] != inter["gene_b"]:
            G.add_edge(inter["gene_a"], inter["gene_b"], weight=inter["score"])
    return G


def compute_topology(G, nem_map):
    degree = dict(G.degree())
    betweenness = nx.betweenness_centrality(G)
    closeness = nx.closeness_centrality(G)
    eigenvector = nx.eigenvector_centrality_numpy(G) if G.number_of_edges() > 0 else {n: 0 for n in G}
    rows = []
    for node in G.nodes():
        rows.append({
            "gene": node,
            "nem_density": nem_map.get(node, 0),
            "degree": degree[node],
            "betweenness": betweenness[node],
            "closeness": closeness[node],
            "eigenvector": eigenvector[node],
            "is_drug_efflux": node in DRUG_EFFLUX_GENES,
        })
    return pd.DataFrame(rows)


def compute_fragility(topo_df):
    n = len(topo_df)
    max_nem = topo_df["nem_density"].max()
    df = topo_df.copy()
    df["fragility_score"] = (
        0.4 * (df["nem_density"] / max_nem if max_nem > 0 else 0) +
        0.3 * (df["degree"] / n) +
        0.3 * (df["nem_density"] / max_nem if max_nem > 0 else 0)
    )
    return df.sort_values("fragility_score", ascending=False)


def main():
    corr_df = load_correlation_df()

    try:
        from importlib.util import spec_from_file_location, module_from_spec
        spec2 = spec_from_file_location("nem_mod", "02_nem_analysis.py")
        mod2 = module_from_spec(spec2)
        spec2.loader.exec_module(mod2)
        spec3 = spec_from_file_location("stress_mod", "03_stress_element_analysis.py")
        mod3 = module_from_spec(spec3)
        spec3.loader.exec_module(mod3)

        nullomers = mod2.load_nullomers(os.path.join(RESULTS_DIR, "nullomers_k11.txt"))
        gene_coords = mod2.parse_gff(os.path.join("data", "yeast.gff3.gz"))
        genome_dict = mod2.load_genome_dict(os.path.join("data", "yeast_genome.fsa"))

        abc_sequences = {}
        for gene in mod2.ABC_TRANSPORTERS:
            if gene in gene_coords:
                seqs = mod2.extract_sequences(gene, gene_coords, genome_dict,
                                              mod2.PROMOTER_LENGTH, mod2.DOWNSTREAM_LENGTH)
                if seqs:
                    abc_sequences[gene] = seqs

        nem_results = {}
        for gene in abc_sequences:
            nem_results[gene] = {
                "gene": mod2.find_nems(abc_sequences[gene]["gene"], nullomers, mod2.K),
                "promoter": mod2.find_nems(abc_sequences[gene]["promoter"], nullomers, mod2.K),
                "downstream": mod2.find_nems(abc_sequences[gene]["downstream"], nullomers, mod2.K),
            }

        stress_results = mod3.scan_stress_elements(abc_sequences)
        ml_df = build_window_features(abc_sequences, nem_results, stress_results)
        importance_df, perf = run_random_forest(ml_df)
        importance_df.to_csv(os.path.join(RESULTS_DIR, "ml_feature_importance.csv"), index=False)
        print(f"RF: test R²={perf['test_r2']}  RMSE={perf['test_rmse']}  "
              f"CV R²={perf['cv_r2_mean']}±{perf['cv_r2_std']}")

    except Exception as e:
        perf = {}
        print(f"ML skipped: {e}")

    gp_stats = run_gp_landscape(corr_df)
    perf.update(gp_stats)
    print(f"GP landscape: R²={gp_stats['gp_r2']}  RMSE={gp_stats['gp_rmse']}")

    with open(os.path.join(RESULTS_DIR, "ml_model_performance.json"), "w") as f:
        json.dump(perf, f, indent=2)

    genes = corr_df["gene"].tolist()
    nem_map = dict(zip(corr_df["gene"], corr_df["nem_density_per_kb"]))
    interactions = fetch_string_interactions(genes)
    G = build_network(genes, interactions, nem_map)
    topo_df = compute_topology(G, nem_map)
    frag_df = compute_fragility(topo_df)

    topo_df.to_csv(os.path.join(RESULTS_DIR, "network_topology.csv"), index=False)
    frag_df.to_csv(os.path.join(RESULTS_DIR, "fragility_scores.csv"), index=False)

    for metric in ["degree", "betweenness", "closeness", "eigenvector"]:
        rho, p = spearmanr(topo_df[metric], topo_df["nem_density"])
        print(f"  {metric:12s}: rho={rho:.3f}  p={p:.4f}")

    # Louvain community detection
    try:
        import community as community_louvain
    except ImportError:
        import subprocess, sys
        subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", "python-louvain"])
        import community as community_louvain

    partition = community_louvain.best_partition(G, random_state=42)
    community_rows = []
    community_ids = set(partition.values())
    for cid in sorted(community_ids):
        members = [g for g, c in partition.items() if c == cid]
        mean_nem = float(np.mean([nem_map.get(g, 0) for g in members]))
        n_drug_efflux = sum(1 for g in members if g in DRUG_EFFLUX_GENES)
        community_rows.append({
            "community_id": cid,
            "n_genes": len(members),
            "genes": ",".join(sorted(members)),
            "mean_nem_density": round(mean_nem, 2),
            "n_drug_efflux": n_drug_efflux,
        })
    community_df = pd.DataFrame(community_rows).sort_values("mean_nem_density", ascending=False)
    community_df.to_csv(os.path.join(RESULTS_DIR, "network_communities.csv"), index=False)
    print(f"Communities: {len(community_ids)}  "
          f"highest NEM community: {community_df.iloc[0]['mean_nem_density']:.1f} NEMs/kb  "
          f"({community_df.iloc[0]['n_drug_efflux']} drug efflux genes)")


if __name__ == "__main__":
    main()