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()