Create predict_dir.py

predict_dir.py

@@ -2,25 +2,31 @@
 # -*- coding: utf-8 -*-
 
 """
-predict_models_dir_with_truth.py
+predict_models_dir.py
 
-Predykcja dla wszystkich modeli w results_models/ na folderze genomów FASTA,
-z adnotacją ground truth z pliku TSV (genomes-all_metadata_with_genetic_code_id_noNA.tsv).
+Predict for all models in models_dir on a folder of FASTA genomes.
+Optionally annotate with ground truth from a TSV and compute the same metrics
+as in your original script (overall + Isolate + MAG + AUC).
 
-Ground truth:
+Inputs:
+  --genomes_dir   Folder with FASTA files (.fna/.fa/.fasta)
+  --models_dir    Folder with model_*.joblib + feature_columns_*.json
+  --outdir        Output folder
+  --truth_tsv     OPTIONAL: genomes-all_metadata_with_genetic_code_id_noNA.tsv
+                  (must contain Genome, Genome_type, Genetic_code_ID)
+
+Ground truth (if provided):
   ALT = Genetic_code_ID != 11
   STD = Genetic_code_ID == 11
 
-Dodatkowo rozbicie metryk dla:
-  - Genome_type == "Isolate"
-  - Genome_type == "MAG"
-
-Wyniki:
-  - predictions/<model>__pred.csv (per model, per genome)
-  - predictions/all_models_predictions_long.csv (long: model x genome)
-  - predictions/prediction_summary.csv (overall + Isolate + MAG + AUC)
+Outputs:
+  - <outdir>/<model>__pred.csv                          (per model, per genome)
+  - <outdir>/all_models_predictions_long.csv            (long: model x genome)
+  - <outdir>/prediction_summary.csv                     (ONLY if truth_tsv is provided)
+  - <outdir>/top_models_by_pr_auc.txt                   (ONLY if truth_tsv is provided)
 
-Wymaga: aragorn w PATH (lub --aragorn).
+Requires:
+  - aragorn in PATH (or pass --aragorn)
 """
 
 import os
@@ -36,7 +42,6 @@ import numpy as np
 import pandas as pd
 from joblib import load as joblib_load
 
-# For metrics
 from sklearn.metrics import (
     confusion_matrix,
     accuracy_score,
@@ -47,11 +52,12 @@ from sklearn.metrics import (
     average_precision_score,
 )
 
+from sklearn.base import BaseEstimator, ClassifierMixin, clone
+
+
 # =========================
 # PU class (for joblib load)
 # =========================
-from sklearn.base import BaseEstimator, ClassifierMixin, clone
-
 class PUBaggingClassifier(BaseEstimator, ClassifierMixin):
     def __init__(self, base_estimator, n_bags=15, u_ratio=3.0, random_state=42):
         self.base_estimator = base_estimator
@@ -254,22 +260,17 @@ def build_features_for_genome(fasta_path, aragorn_bin, feature_columns, reuse_ar
 
 
 # =========================
-# Ground truth from TSV
+# Ground truth from TSV (optional)
 # =========================
 def load_truth_tsv(tsv_path: str) -> pd.DataFrame:
     df = pd.read_csv(tsv_path, sep="\t", dtype=str)
-    # Normalize key columns
-    if "Genome" not in df.columns:
-        raise ValueError(f"TSV missing column 'Genome'. Columns: {list(df.columns)}")
-    if "Genome_type" not in df.columns:
-        raise ValueError(f"TSV missing column 'Genome_type'. Columns: {list(df.columns)}")
-    if "Genetic_code_ID" not in df.columns:
-        raise ValueError(f"TSV missing column 'Genetic_code_ID'. Columns: {list(df.columns)}")
+
+    for col in ["Genome", "Genome_type", "Genetic_code_ID"]:
+        if col not in df.columns:
+            raise ValueError(f"TSV missing column '{col}'. Columns: {list(df.columns)}")
 
     df["Genome"] = df["Genome"].astype(str)
     df["Genome_type"] = df["Genome_type"].astype(str)
-
-    # Genetic_code_ID -> int
     df["Genetic_code_ID"] = pd.to_numeric(df["Genetic_code_ID"], errors="coerce").astype("Int64")
 
     # ALT ground truth: != 11
@@ -280,7 +281,7 @@ def load_truth_tsv(tsv_path: str) -> pd.DataFrame:
 
 
 # =========================
-# Metrics
+# Metrics (only if truth exists)
 # =========================
 def safe_confusion(y_true, y_pred):
     cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
@@ -308,7 +309,6 @@ def compute_metrics_block(y_true, y_pred, y_score=None):
         "fp_rate": float(fp / (fp + tn)) if (fp + tn) > 0 else np.nan,
     }
 
-    # AUCs only if y_score provided and both classes exist
     if y_score is not None:
         y_score = np.asarray(y_score, dtype=float)
         if n > 0 and len(np.unique(y_true)) == 2:
@@ -352,14 +352,20 @@ def pick_feature_cols(models_dir: Path, feature_cols_arg: str | None):
 # Main
 # =========================
 def main():
-    ap = argparse.ArgumentParser(description="Predict for all models in a directory + annotate truth from TSV.")
-    ap.add_argument("--genomes_dir", required=True, help="Folder z genomami FASTA (.fna/.fa/.fasta).")
-    ap.add_argument("--models_dir", required=True, help="Folder z modelami (.joblib) + feature_columns_*.json.")
-    ap.add_argument("--outdir", required=True, help="Folder wyjściowy na predykcje CSV.")
-    ap.add_argument("--aragorn", default="aragorn", help="Ścieżka do binarki ARAGORN.")
-    ap.add_argument("--feature_cols", default=None, help="Opcjonalnie: wymuś konkretny feature_columns_*.json.")
-    ap.add_argument("--reuse_aragorn", action="store_true", help="Jeśli istnieje *.aragorn.txt i jest świeży, użyj go.")
-    ap.add_argument("--truth_tsv", required=True, help="genomes-all_metadata_with_genetic_code_id_noNA.tsv")
+    ap = argparse.ArgumentParser(
+        description="Predict for all models in a directory; optionally annotate truth from TSV and compute metrics."
+    )
+    ap.add_argument("--genomes_dir", required=True, help="Folder with FASTA genomes (.fna/.fa/.fasta).")
+    ap.add_argument("--models_dir", required=True, help="Folder with model_*.joblib + feature_columns_*.json.")
+    ap.add_argument("--outdir", required=True, help="Output folder for CSV predictions.")
+    ap.add_argument("--aragorn", default="aragorn", help="Path to ARAGORN binary.")
+    ap.add_argument("--feature_cols", default=None, help="Optional: force a specific feature_columns_*.json.")
+    ap.add_argument("--reuse_aragorn", action="store_true", help="Reuse *.aragorn.txt if it exists and is fresh.")
+    ap.add_argument(
+        "--truth_tsv",
+        default=None,
+        help="OPTIONAL: genomes-all_metadata_with_genetic_code_id_noNA.tsv (Genome, Genome_type, Genetic_code_ID).",
+    )
     args = ap.parse_args()
 
     set_single_thread_env()
@@ -369,30 +375,30 @@ def main():
     outdir = Path(args.outdir)
     outdir.mkdir(parents=True, exist_ok=True)
 
-    # Load truth
-    truth = load_truth_tsv(args.truth_tsv)
-    truth_map = truth.set_index("Genome")
-
-    # Input genomes
     fasta_files = list_fasta_files(str(genomes_dir))
     if not fasta_files:
-        raise SystemExit(f"Brak FASTA w {genomes_dir}")
+        raise SystemExit(f"No FASTA files found in {genomes_dir}")
 
     models = find_models(models_dir)
     if not models:
-        raise SystemExit(f"Brak model_*.joblib w {models_dir}")
+        raise SystemExit(f"No model_*.joblib found in {models_dir}")
 
     feat_cols_path = pick_feature_cols(models_dir, args.feature_cols)
 
-    print(f"[INFO] Genomes: {len(fasta_files)} in {genomes_dir}")
-    print(f"[INFO] Models : {len(models)} in {models_dir}")
-    print(f"[INFO] Truth  : {args.truth_tsv}")
+    print(f"[INFO] Genomes : {len(fasta_files)} in {genomes_dir}")
+    print(f"[INFO] Models  : {len(models)} in {models_dir}")
     print(f"[INFO] FeatCols: {feat_cols_path}")
+    print(f"[INFO] Truth   : {args.truth_tsv if args.truth_tsv else '(none)'}")
 
     # Load feature columns
     with open(feat_cols_path, "r") as fh:
         feature_columns = json.load(fh)
 
+    # Optional truth
+    truth = None
+    if args.truth_tsv:
+        truth = load_truth_tsv(args.truth_tsv)
+
     # Build features once (shared across all models)
     t_feat0 = time.time()
     rows, accs = [], []
@@ -411,13 +417,21 @@ def main():
     X = pd.DataFrame(rows, index=accs)[feature_columns]
     print(f"[FEAT] Built X={X.shape} in {(time.time()-t_feat0):.1f}s")
 
-    # Merge truth annotation for these genomes
-    ann = pd.DataFrame({"Genome": accs}).merge(truth, how="left", left_on="Genome", right_on="Genome")
-    n_annot = int(ann["y_true_alt"].notna().sum())
-    n_missing = int(len(ann) - n_annot)
-    print(f"[TRUTH] Annotated: {n_annot}/{len(ann)}  Missing_in_TSV: {n_missing}")
+    # Annotation base table (always exists)
+    ann = pd.DataFrame({"Genome": accs})
+
+    if truth is not None:
+        ann = ann.merge(truth, how="left", on="Genome")
+        n_annot = int(ann["y_true_alt"].notna().sum())
+        n_missing = int(len(ann) - n_annot)
+        print(f"[TRUTH] Annotated: {n_annot}/{len(ann)}  Missing_in_TSV: {n_missing}")
+    else:
+        # Ensure columns exist for consistent outputs
+        ann["Genome_type"] = pd.NA
+        ann["Genetic_code_ID"] = pd.NA
+        ann["y_true_alt"] = pd.NA
+        ann["true_label"] = pd.NA
 
-    # Prepare outputs
     long_rows = []
     summary_rows = []
 
@@ -430,11 +444,15 @@ def main():
         t0 = time.time()
         model = joblib_load(model_path)
 
+        # Probabilities (if possible)
+        proba = None
         if hasattr(model, "predict_proba"):
-            proba = model.predict_proba(X)[:, 1]
-        else:
-            proba = None
+            try:
+                proba = model.predict_proba(X)[:, 1]
+            except Exception:
+                proba = None
 
+        # Pred class
         if hasattr(model, "predict"):
             try:
                 yhat = model.predict(X)
@@ -445,15 +463,11 @@ def main():
 
         elapsed = time.time() - t0
 
-        # Build per-model table with annotations
         df_pred = ann.copy()
         df_pred["model"] = model_name
         df_pred["y_pred_alt"] = np.asarray(yhat).astype(int)
         df_pred["pred_label"] = df_pred["y_pred_alt"].map({0: "STD", 1: "ALT"})
-        if proba is not None:
-            df_pred["proba_alt"] = np.asarray(proba, dtype=float)
-        else:
-            df_pred["proba_alt"] = np.nan
+        df_pred["proba_alt"] = np.asarray(proba, dtype=float) if proba is not None else np.nan
 
         out_csv = outdir / f"{model_name}__pred.csv"
         df_pred.to_csv(out_csv, index=False)
@@ -461,97 +475,94 @@ def main():
 
         # Long output
         keep_cols = ["model", "Genome", "Genome_type", "Genetic_code_ID", "y_true_alt", "y_pred_alt", "proba_alt"]
-        for row in df_pred[keep_cols].itertuples(index=False):
-            long_rows.append({
-                "model": row.model,
-                "Genome": row.Genome,
-                "Genome_type": row.Genome_type,
-                "Genetic_code_ID": row.Genetic_code_ID,
-                "y_true_alt": row.y_true_alt,
-                "y_pred_alt": row.y_pred_alt,
-                "proba_alt": row.proba_alt
-            })
-
-        # Summary metrics ONLY on annotated subset
-        df_eval = df_pred[df_pred["y_true_alt"].notna()].copy()
-        y_true = df_eval["y_true_alt"].astype(int).values
-        y_pred = df_eval["y_pred_alt"].astype(int).values
-        y_score = df_eval["proba_alt"].astype(float).values if proba is not None else None
-
-        overall = compute_metrics_block(y_true, y_pred, y_score=y_score)
-
-        # Isolate / MAG splits
-        def subset_metrics(gen_type: str):
-            sub = df_eval[df_eval["Genome_type"] == gen_type]
-            if sub.shape[0] == 0:
-                return {k: np.nan for k in compute_metrics_block([0,1],[0,1],y_score=np.array([0.1,0.9])).keys()}
-            yt = sub["y_true_alt"].astype(int).values
-            yp = sub["y_pred_alt"].astype(int).values
-            ys = sub["proba_alt"].astype(float).values if proba is not None else None
-            return compute_metrics_block(yt, yp, y_score=ys)
-
-        iso = subset_metrics("Isolate")
-        mag = subset_metrics("MAG")
-
-        # Pack summary row
-        srow = {
-            "model": model_name,
-            "model_file": str(model_path),
-            "feature_cols": str(feat_cols_path),
-            "n_genomes_total": int(len(df_pred)),
-            "n_annotated": int(df_eval.shape[0]),
-            "n_missing_truth": int(len(df_pred) - df_eval.shape[0]),
-            "elapsed_sec": float(elapsed),
-            "elapsed_min": float(elapsed/60.0),
-        }
-
-        # overall prefixed
-        for k, v in overall.items():
-            srow[f"overall_{k}"] = v
-
-        # isolate prefixed
-        for k, v in iso.items():
-            srow[f"isolate_{k}"] = v
-
-        # mag prefixed
-        for k, v in mag.items():
-            srow[f"mag_{k}"] = v
-
-        summary_rows.append(srow)
+        keep_cols = [c for c in keep_cols if c in df_pred.columns]
+        long_rows.extend(df_pred[keep_cols].to_dict(orient="records"))
+
+        # Metrics only if we have truth annotations
+        if truth is not None:
+            df_eval = df_pred[df_pred["y_true_alt"].notna()].copy()
+            if df_eval.shape[0] == 0:
+                print("[METRICS] No annotated genomes for this run (truth TSV did not match Genome names).")
+                continue
+
+            y_true = df_eval["y_true_alt"].astype(int).values
+            y_pred = df_eval["y_pred_alt"].astype(int).values
+            y_score = df_eval["proba_alt"].astype(float).values if proba is not None else None
+
+            overall = compute_metrics_block(y_true, y_pred, y_score=y_score)
+
+            def subset_metrics(gen_type: str):
+                sub = df_eval[df_eval["Genome_type"] == gen_type]
+                if sub.shape[0] == 0:
+                    return None
+                yt = sub["y_true_alt"].astype(int).values
+                yp = sub["y_pred_alt"].astype(int).values
+                ys = sub["proba_alt"].astype(float).values if proba is not None else None
+                return compute_metrics_block(yt, yp, y_score=ys)
+
+            iso = subset_metrics("Isolate")
+            mag = subset_metrics("MAG")
+
+            srow = {
+                "model": model_name,
+                "model_file": str(model_path),
+                "feature_cols": str(feat_cols_path),
+                "n_genomes_total": int(len(df_pred)),
+                "n_annotated": int(df_eval.shape[0]),
+                "n_missing_truth": int(len(df_pred) - df_eval.shape[0]),
+                "elapsed_sec": float(elapsed),
+                "elapsed_min": float(elapsed/60.0),
+            }
+
+            for k, v in overall.items():
+                srow[f"overall_{k}"] = v
+
+            if iso is not None:
+                for k, v in iso.items():
+                    srow[f"isolate_{k}"] = v
+
+            if mag is not None:
+                for k, v in mag.items():
+                    srow[f"mag_{k}"] = v
+
+            summary_rows.append(srow)
 
     # Write combined outputs
     long_csv = outdir / "all_models_predictions_long.csv"
     pd.DataFrame(long_rows).to_csv(long_csv, index=False)
     print(f"\n[WRITE] {long_csv} rows={len(long_rows)}")
 
-    summary_csv = outdir / "prediction_summary.csv"
-    df_sum = pd.DataFrame(summary_rows)
-    df_sum.to_csv(summary_csv, index=False)
-    print(f"[WRITE] {summary_csv} rows={len(df_sum)}")
-
-    # End report: best PR-AUC overall (if available)
-    if "overall_pr_auc" in df_sum.columns:
-        df_rank = df_sum.sort_values(["overall_pr_auc", "overall_roc_auc"], ascending=False, na_position="last")
-        print("\n" + "="*80)
-        print("[REPORT] Top models by overall PR-AUC (ground truth ALT = Genetic_code_ID != 11):")
-        cols = [
-            "model",
-            "n_annotated",
-            "overall_positives",
-            "overall_precision",
-            "overall_recall",
-            "overall_f1",
-            "overall_pr_auc",
-            "overall_roc_auc",
-            "isolate_fn", "isolate_fp", "mag_fn", "mag_fp",
-            "elapsed_min",
-        ]
-        cols = [c for c in cols if c in df_rank.columns]
-        print(df_rank[cols].head(15).to_string(index=False))
-        print("="*80)
+    if truth is not None:
+        summary_csv = outdir / "prediction_summary.csv"
+        df_sum = pd.DataFrame(summary_rows)
+        df_sum.to_csv(summary_csv, index=False)
+        print(f"[WRITE] {summary_csv} rows={len(df_sum)}")
+
+        # Top models report
+        if not df_sum.empty and "overall_pr_auc" in df_sum.columns:
+            df_rank = df_sum.sort_values(["overall_pr_auc", "overall_roc_auc"], ascending=False, na_position="last")
+            report_path = outdir / "top_models_by_pr_auc.txt"
+            cols = [
+                "model",
+                "n_annotated",
+                "overall_positives",
+                "overall_precision",
+                "overall_recall",
+                "overall_f1",
+                "overall_pr_auc",
+                "overall_roc_auc",
+                "isolate_fn", "isolate_fp", "mag_fn", "mag_fp",
+                "elapsed_min",
+            ]
+            cols = [c for c in cols if c in df_rank.columns]
+            with open(report_path, "w", encoding="utf-8") as f:
+                f.write("Top models by overall PR-AUC (ALT = Genetic_code_ID != 11)\n")
+                f.write(df_rank[cols].head(25).to_string(index=False))
+                f.write("\n")
+            print(f"[WRITE] {report_path}")
 
     print("[DONE]")
 
+
 if __name__ == "__main__":
     main()
-