Upload 125 files

.gitattributes

@@ -57,3 +57,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+FEATURES_ALL.ndjson filter=lfs diff=lfs merge=lfs -text
+predictions_truth/all_models_predictions_long.csv filter=lfs diff=lfs merge=lfs -text
+Supp1.csv filter=lfs diff=lfs merge=lfs -text
+Supp2.xlsx filter=lfs diff=lfs merge=lfs -text

80_20_split_fixed.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# 80_20_proportion.py  stratified 80/20 split with Bacteria filter & grouped by base accession (GCA/GCF).
+# Input: --ndjson (NDJSON), --supp1 (optional Supp1.csv filter: domain B by assembly), --supp2 (Supp2.xlsx for labels)
+# Output: subsetXX/train.jsonl, subsetXX/test.jsonl, subsetXX/manifest.json
+#
+# CHANGE: Remove contaminated assemblies listed in Supp2.xlsx where
+#         "Evidence of assembly contamination with alt gen code" == "yes"
+#         (based on the "assembly" column).
+
+import argparse, json, re, sys
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import StratifiedGroupKFold
+
+def extract_acc_base(acc: str) -> str:
+    m = re.match(r'^(G[CF]A_\d+)', str(acc))
+    return m.group(1) if m else str(acc).split('.')[0]
+
+def load_bacterial_bases_from_supp1(supp1_csv: str) -> set:
+    df = pd.read_csv(supp1_csv)
+    cols = {c.lower().strip(): c for c in df.columns}
+    dom_col = cols.get('domain of life') or cols.get('domain_of_life') or cols.get('domain') or 'domain of life'
+    asm_col = cols.get('assembly') or cols.get('assembly accession') or 'assembly'
+    if dom_col not in df.columns or asm_col not in df.columns:
+        raise ValueError(f"Supp1.csv must contain columns similar to 'domain of life' and 'assembly'. Found: {list(df.columns)}")
+    mask = df[dom_col].astype(str).str.strip().str.upper().eq('B')
+    df_b = df.loc[mask, [asm_col]].dropna()
+    bases = set(extract_acc_base(a) for a in df_b[asm_col].astype(str))
+    return bases
+
+def load_alt_bases_from_supp2_legacy(supp2_xlsx: str) -> set:
+    """
+    ORIGINAL behavior (kept): column index-based extraction.
+    WARNING: This assumes the 4th column (usecols=[3]) contains assembly IDs for the ALT label.
+    """
+    df = pd.read_excel(supp2_xlsx, header=None, usecols=[3])
+    alt = (
+        df.iloc[:, 0]
+        .dropna()
+        .astype(str)
+        .unique()
+        .tolist()
+    )
+    return set(extract_acc_base(x) for x in alt)
+
+def load_contam_bases_from_supp2(supp2_xlsx: str) -> set:
+    """
+    NEW: assemblies to REMOVE (contaminated), where:
+      Evidence of assembly contamination with alt gen code == 'yes'
+    Uses named columns: 'assembly' + 'Evidence of assembly contamination with alt gen code'
+    """
+    df = pd.read_excel(supp2_xlsx)
+
+    cols = {c.lower().strip(): c for c in df.columns}
+    asm_col = cols.get('assembly')
+    ev_col  = cols.get('evidence of assembly contamination with alt gen code')
+
+    if asm_col is None or ev_col is None:
+        raise ValueError(
+            "Supp2.xlsx must contain columns 'assembly' and "
+            "'Evidence of assembly contamination with alt gen code' to filter contaminated rows. "
+            f"Found columns: {list(df.columns)}"
+        )
+
+    mask = (
+        df[ev_col]
+        .astype(str)
+        .str.strip()
+        .str.lower()
+        .eq('yes')
+    )
+
+    contam_bases = (
+        df.loc[mask, asm_col]
+        .dropna()
+        .astype(str)
+        .apply(extract_acc_base)
+        .unique()
+        .tolist()
+    )
+
+    return set(contam_bases)
+
+def read_ndjson_records(path: str):
+    with open(path, 'r') as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                yield json.loads(line)
+            except Exception:
+                continue
+
+def main():
+    ap = argparse.ArgumentParser(description="Create grouped stratified 80/20 splits compatible with Mass_models.py")
+    ap.add_argument('--ndjson', required=True, help='Input NDJSON file (one JSON per line)')
+    ap.add_argument('--supp1', required=False, help='Optional Supp1.csv filter: keep only Bacteria (domain==B) by assembly')
+    ap.add_argument('--supp2', required=True, help='Supp2.xlsx (used for legacy alt labels + contamination filter)')
+    ap.add_argument('--outdir', required=True, help='Output directory root for subsets')
+    ap.add_argument('--n_splits', type=int, default=1, help='Number of replicate 80/20 splits')
+    ap.add_argument('--seed', type=int, default=42, help='Random seed')
+    args = ap.parse_args()
+
+    ndjson_path = Path(args.ndjson)
+    if not ndjson_path.exists():
+        sys.exit(f"[ERR ] NDJSON not found: {ndjson_path}")
+
+    bacteria_bases = None
+    if args.supp1:
+        print(f"[FILTER] Loading Supp1 (Bacteria-only by 'domain of life' & 'assembly')…")
+        bacteria_bases = load_bacterial_bases_from_supp1(args.supp1)
+        print(f"[FILTER] Allowed assembly bases: {len(bacteria_bases)}")
+
+    # Original label behavior preserved
+    alt_bases = load_alt_bases_from_supp2_legacy(args.supp2)
+    print(f"[LABEL] Alt bases from Supp2 (legacy col[3]): {len(alt_bases)}")
+
+    # NEW: contaminated -> remove
+    contam_bases = load_contam_bases_from_supp2(args.supp2)
+    print(f"[FILTER] Contaminated bases from Supp2 where evidence == 'yes': {len(contam_bases)}")
+
+    # If something is both "alt" (legacy) and contaminated, it MUST be removed.
+    overlap = len(alt_bases & contam_bases)
+    if overlap:
+        print(f"[WARN ] Overlap alt vs contaminated: {overlap} bases (will be REMOVED from dataset)")
+
+    print(f"[LOAD ] Reading NDJSON: {ndjson_path}")
+    records, groups, y = [], [], []
+    dropped_contam = 0
+    dropped_supp1 = 0
+
+    for obj in read_ndjson_records(str(ndjson_path)):
+        acc = obj.get("acc")
+        if not acc:
+            continue
+        base = extract_acc_base(acc)
+
+        # Optional bacteria-only filter
+        if bacteria_bases is not None and base not in bacteria_bases:
+            dropped_supp1 += 1
+            continue
+
+        # NEW contamination filter (REMOVE)
+        if base in contam_bases:
+            dropped_contam += 1
+            continue
+
+        records.append(obj)
+        groups.append(base)
+        y.append(1 if base in alt_bases else 0)
+
+    if not records:
+        sys.exit("[ERR ] No records after filtering. Check Supp1 filter / Supp2 contamination filter / NDJSON.")
+
+    y = np.array(y, dtype=int)
+    pos = int(y.sum())
+    print(
+        f"[DATA ] kept={len(records)} | positives={pos} ({100.0*pos/len(records):.2f}%) | "
+        f"groups={len(set(groups))} | dropped_contam={dropped_contam} | dropped_supp1={dropped_supp1}"
+    )
+
+    outroot = Path(args.outdir)
+    outroot.mkdir(parents=True, exist_ok=True)
+
+    sgkf = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=args.seed)
+
+    for k in range(args.n_splits):
+        subset_dir = outroot / f"subset{k+1:02d}"
+        subset_dir.mkdir(parents=True, exist_ok=True)
+
+        idx = np.arange(len(records))
+        tr_idx, te_idx = next(sgkf.split(idx, y, groups))
+        train_records = [records[i] for i in tr_idx]
+        test_records  = [records[i] for i in te_idx]
+
+        with open(subset_dir / "train.jsonl", "w") as ftr:
+            for r in train_records:
+                ftr.write(json.dumps(r, separators=(',', ':')) + "\n")
+        with open(subset_dir / "test.jsonl", "w") as fte:
+            for r in test_records:
+                fte.write(json.dumps(r, separators=(',', ':')) + "\n")
+
+        y_tr = y[tr_idx]; y_te = y[te_idx]
+        manifest = {
+            "n_total": int(len(records)),
+            "n_train": int(len(train_records)),
+            "n_test": int(len(test_records)),
+            "positives_total": int(y.sum()),
+            "positives_train": int(y_tr.sum()),
+            "positives_test": int(y_te.sum()),
+            "pct_pos_total": float(100.0 * y.sum() / len(records)),
+            "pct_pos_train": float(100.0 * y_tr.sum() / len(train_records)),
+            "pct_pos_test": float(100.0 * y_te.sum() / len(test_records)),
+            "groups_total": int(len(set(groups))),
+            "seed": int(args.seed + k),
+            "source_ndjson": str(ndjson_path.resolve()),
+            "supp2_contam_removed": int(len(contam_bases)),
+        }
+        (subset_dir / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+        print(f"[WRITE] {subset_dir} | train={len(train_records)} test={len(test_records)} | pos_tr={int(y_tr.sum())} pos_te={int(y_te.sum())}")
+
+    print("[DONE ] All subsets written.")
+
+if __name__ == "__main__":
+    main()
+

FEATURES_ALL.ndjson

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2316d3eab9d4900a9902eafb7c6112e3bb412c32d7a80816b0ce7a8e4634313a
+size 1751164568

Mass_models.py

@@ -0,0 +1,987 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Mass_models.py Grouped-CV training with calibration & thresholding on tRNA profiles.
+# Supports:
+#   - train_mode: supervised / pu / both
+#   - weight_mode: normal / weighted / both
+#   - models: RF / XGB / ET (ExtraTrees)
+#   - metrics: F1 / PR_AUC / FB
+#
+# Input: ndjson train/test with 64-log + GC + tetra_norm (full row from ndjson).
+# Labels: positives are assemblies present in Supp2 (NOT treated as certain ALT, only candidates).
+# Weighted mode: assigns confidence weights ONLY to Supp2 genomes using Supp1 expected vs inferred,
+# with gentle GC gating.
+#
+# NEW FIXES:
+#   - Proper sample_weight routing into sklearn Pipeline: clf__sample_weight
+#   - PU classifier marked as classifier for sklearn calibration (_estimator_type + classifier tags)
+#   - Optional calibration auto-disabled for PU by default (still possible with --force_calibration_pu)
+#   - Skip already-trained model variants based on existing artifacts in results_models/
+#   - Crash-safe: each run saved immediately, and metrics_summary.csv updated after each run
+#
+# NOTE:
+#   - For PU, calibration can be extremely expensive (cv * n_bags refits). Default: off for PU unless forced.
+
+import argparse, json, os, re, time, glob
+from pathlib import Path
+from collections import Counter
+
+import numpy as np
+import pandas as pd
+
+from sklearn.model_selection import StratifiedGroupKFold
+from sklearn.metrics import (
+    f1_score, confusion_matrix, accuracy_score, precision_score, recall_score,
+    fbeta_score, roc_auc_score, average_precision_score, precision_recall_curve
+)
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier
+from sklearn.impute import SimpleImputer
+from sklearn.calibration import CalibratedClassifierCV
+from sklearn.base import BaseEstimator, ClassifierMixin, clone
+
+import joblib
+
+try:
+    from xgboost import XGBClassifier
+    _HAS_XGB = True
+except Exception:
+    _HAS_XGB = False
+
+import optuna
+from optuna.pruners import MedianPruner
+
+ANTICODONS64 = [a+b+c for a in "ACGT" for b in "ACGT" for c in "ACGT"]
+TETRA_KEYS   = [a+b+c+d for a in "ACGT" for b in "ACGT" for c in "ACGT" for d in "ACGT"]
+
+AA_SET = set(list("ACDEFGHIKLMNPQRSTVWY"))
+STAR = "*"
+QMARK = "?"
+
+# =========================
+# Helpers: crash-safe fit with sample_weight
+# =========================
+def fit_pipeline(model, X, y, sample_weight=None):
+    """
+    Fit helper that correctly routes sample_weight into Pipeline
+    (to the 'clf' step) and also supports plain estimators.
+    """
+    if sample_weight is None:
+        return model.fit(X, y)
+
+    sw = np.asarray(sample_weight)
+
+    # sklearn Pipeline cannot accept sample_weight directly
+    if isinstance(model, Pipeline):
+        return model.fit(X, y, clf__sample_weight=sw)
+
+    # many estimators accept sample_weight directly
+    try:
+        return model.fit(X, y, sample_weight=sw)
+    except TypeError:
+        return model.fit(X, y)
+
+# =========================
+# PU Bagging Meta-Estimator
+# =========================
+class PUBaggingClassifier(BaseEstimator, ClassifierMixin):
+    """
+    PU-learning via bagging:
+      - y==1: positives (P)  [assemblies from Supp2]
+      - y==0: unlabeled (U)  [everything else]
+    For each bag:
+      - train on all P + sampled subset of U as pseudo-negative
+    predict_proba: average over bags.
+
+    sklearn calibration fix:
+      - _estimator_type='classifier'
+      - get tags / is_classifier compatibility
+    """
+    _estimator_type = "classifier"
+
+    def __init__(self, base_estimator, n_bags=15, u_ratio=3.0, random_state=42):
+        self.base_estimator = base_estimator
+        self.n_bags = int(n_bags)
+        self.u_ratio = float(u_ratio)
+        self.random_state = int(random_state)
+        self.models_ = None
+        self.classes_ = np.array([0, 1], dtype=int)
+
+    def _more_tags(self):
+        # Helps sklearn treat this as classifier with predict_proba.
+        return {"requires_y": True, "binary_only": True}
+
+    def fit(self, X, y, sample_weight=None):
+        y = np.asarray(y).astype(int)
+        self.classes_ = np.array([0, 1], dtype=int)
+
+        pos_idx = np.where(y == 1)[0]
+        unl_idx = np.where(y == 0)[0]
+
+        if pos_idx.size == 0:
+            raise ValueError("PU training requires at least one positive sample (y==1).")
+
+        rng = np.random.RandomState(self.random_state)
+        self.models_ = []
+
+        # if no unlabeled, just fit once
+        if unl_idx.size == 0:
+            m = clone(self.base_estimator)
+            fit_pipeline(m, X, y, sample_weight)
+            self.models_.append(m)
+            return self
+
+        k_u = int(min(unl_idx.size, max(1, round(self.u_ratio * pos_idx.size))))
+
+        for _ in range(self.n_bags):
+            if k_u <= unl_idx.size:
+                u_b = rng.choice(unl_idx, size=k_u, replace=False)
+            else:
+                u_b = rng.choice(unl_idx, size=k_u, replace=True)
+
+            idx_b = np.concatenate([pos_idx, u_b])
+
+            X_b = X.iloc[idx_b] if hasattr(X, "iloc") else X[idx_b]
+            y_b = y[idx_b]
+
+            sw_b = None
+            if sample_weight is not None:
+                sw_b = np.asarray(sample_weight)[idx_b]
+
+            m = clone(self.base_estimator)
+            fit_pipeline(m, X_b, y_b, sw_b)
+            self.models_.append(m)
+
+        return self
+
+    def predict_proba(self, X):
+        if not self.models_:
+            raise RuntimeError("PUBaggingClassifier not fitted")
+        probs = [m.predict_proba(X) for m in self.models_]
+        return np.mean(np.stack(probs, axis=0), axis=0)
+
+    def predict(self, X):
+        return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)
+
+# =========================
+# Helpers: IDs, NDJSON features
+# =========================
+def extract_acc_base(acc: str) -> str:
+    m = re.match(r'^(G[CF]A_\d+)', str(acc))
+    return m.group(1) if m else str(acc).split('.')[0]
+
+def load_alt_list_from_supp2(supp2_xlsx: str) -> set:
+    df = pd.read_excel(supp2_xlsx, header=None, usecols=[3])
+    alt = df.iloc[:, 0].dropna().astype(str).unique().tolist()
+    return set(extract_acc_base(x) for x in alt)
+
+def label_from_supp2(meta: pd.DataFrame, supp2_xlsx: str) -> pd.Series:
+    alt = load_alt_list_from_supp2(supp2_xlsx)
+    return meta["acc_base"].map(lambda a: 1 if a in alt else 0).astype(int)
+
+def parse_anticodon_from_label(label_tail: str) -> str:
+    if "_" in label_tail:
+        return label_tail.split("_", 1)[1].upper().replace("U","T")
+    return label_tail.upper().replace("U","T")
+
+def build_vec64_from_record(rec: dict) -> np.ndarray:
+    counter = Counter()
+    for t in rec.get("trna_type_per_acc", []):
+        c = int(t.get("count", 0) or 0)
+        tail = str(t.get("label", "")).split("_genome_")[-1]
+        ac = parse_anticodon_from_label(tail)
+        if len(ac) == 3 and set(ac) <= {"A","C","G","T"}:
+            counter[ac] += c
+    return np.array([counter.get(k, 0) for k in ANTICODONS64], dtype=float)
+
+def build_feature_matrices(ndjson_path: str, include_gc_len_tetra: bool = True):
+    rows = []
+    with open(ndjson_path, "r") as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except Exception:
+                continue
+
+    feat_rows, meta_rows = [], []
+    for rec in rows:
+        acc = rec.get("acc")
+        if not acc:
+            continue
+        acc_base = extract_acc_base(acc)
+        gc = rec.get("gc", {})
+        tetra = rec.get("tetra_norm", {})
+
+        v64 = build_vec64_from_record(rec)
+        vals = np.log1p(v64)
+        cols = [f"ac_{k}" for k in ANTICODONS64]
+        trna_dict = {c: float(v) for c, v in zip(cols, vals)}
+
+        extra = {}
+        if include_gc_len_tetra:
+            extra["gc_percent"] = float(gc.get("percent", np.nan))
+            extra["genome_length"] = int(gc.get("length", 0) or 0)
+            for k in TETRA_KEYS:
+                extra[f"tetra_{k}"] = float(tetra.get(k, np.nan))
+
+        feat_rows.append({**trna_dict, **extra})
+        meta_rows.append({"acc": acc, "acc_base": acc_base})
+
+    X = pd.DataFrame(feat_rows)
+    meta = pd.DataFrame(meta_rows)
+    return X, meta
+
+def _count_lines(path: Path) -> int:
+    try:
+        return sum(1 for _ in open(path, 'r'))
+    except Exception:
+        return -1
+
+def _load_train_test(path_str: str, supp2_path: str):
+    p = Path(path_str)
+    if not p.is_dir():
+        raise FileNotFoundError(f"--ndjson must be a directory containing train.jsonl and test.jsonl: {p}")
+    tr = p / "train.jsonl"
+    te = p / "test.jsonl"
+    if not tr.exists() or not te.exists():
+        raise FileNotFoundError(f"{p} must contain train.jsonl and test.jsonl")
+
+    print(f"[LOAD] train: {tr} (lines≈{_count_lines(tr)})")
+    Xtr, mtr = build_feature_matrices(str(tr), True)
+    print(f"[LOAD]  test: {te} (lines≈{_count_lines(te)})")
+    Xte, mte = build_feature_matrices(str(te), True)
+
+    ytr = label_from_supp2(mtr, supp2_path)  # P=1 (Supp2), U=0 otherwise
+    yte = label_from_supp2(mte, supp2_path)
+
+    gtr = mtr["acc_base"].tolist()
+    gte = mte["acc_base"].tolist()
+    return Xtr, ytr, gtr, mtr, Xte, yte, gte, mte
+
+def make_preprocess_pipeline(X: pd.DataFrame) -> ColumnTransformer:
+    num_cols = list(X.columns)
+    pre_num = Pipeline([
+        ("imputer", SimpleImputer(strategy="median")),
+        ("scaler", StandardScaler(with_mean=True, with_std=True))
+    ])
+    return ColumnTransformer(
+        [("num", pre_num, num_cols)],
+        remainder="drop",
+        verbose_feature_names_out=False
+    )
+
+# =========================
+# Supp1 parsing -> weights for Supp2 only
+# =========================
+def _norm_code_str(x) -> str:
+    if pd.isna(x):
+        return ""
+    return str(x).replace(",", "").replace(" ", "").strip().upper()
+
+def _analyze_expected_inferred(expected: str, inferred: str):
+    """
+    Return counts:
+      aa_aa: AA<->AA different
+      aa_q : AA<->?
+      stop_aa: *<->AA
+      stop_q : *<->?
+      total_q: positions with '?' in either string
+      valid: both length 64
+    """
+    e = _norm_code_str(expected)
+    i = _norm_code_str(inferred)
+    if len(e) != 64 or len(i) != 64:
+        return dict(valid=False, aa_aa=0, aa_q=0, stop_aa=0, stop_q=0, total_q=0)
+
+    aa_aa = aa_q = stop_aa = stop_q = total_q = 0
+
+    for a, b in zip(e, i):
+        if a == QMARK or b == QMARK:
+            total_q += 1
+
+        if a == b:
+            continue
+
+        a_is_aa = a in AA_SET
+        b_is_aa = b in AA_SET
+        a_is_q  = a == QMARK
+        b_is_q  = b == QMARK
+        a_is_s  = a == STAR
+        b_is_s  = b == STAR
+
+        if a_is_aa and b_is_aa:
+            aa_aa += 1
+        elif (a_is_aa and b_is_q) or (a_is_q and b_is_aa):
+            aa_q += 1
+        elif (a_is_s and b_is_aa) or (a_is_aa and b_is_s):
+            stop_aa += 1
+        elif (a_is_s and b_is_q) or (a_is_q and b_is_s):
+            stop_q += 1
+        else:
+            pass
+
+    return dict(valid=True, aa_aa=aa_aa, aa_q=aa_q, stop_aa=stop_aa, stop_q=stop_q, total_q=total_q)
+
+def load_supp1_code_map(supp1_csv: str):
+    """
+    Returns dict base_assembly -> (expected_str, inferred_str)
+    Uses columns:
+      - assembly
+      - expected genetic code
+      - Codetta inferred genetic code
+    """
+    df = pd.read_csv(supp1_csv)
+    cols = {c.lower(): c for c in df.columns}
+
+    def pick(key_sub):
+        for k in cols:
+            if k == key_sub:
+                return cols[k]
+        for k in cols:
+            if key_sub in k:
+                return cols[k]
+        return None
+
+    asm_col = pick("assembly")
+    exp_col = pick("expected genetic code")
+    inf_col = pick("codetta inferred genetic code")
+
+    if not (asm_col and exp_col and inf_col):
+        raise ValueError(f"[ERROR] Supp1.csv missing required columns. Found: {list(df.columns)}")
+
+    out = {}
+    for _, row in df.iterrows():
+        asm = str(row[asm_col])
+        base = extract_acc_base(asm)
+        out[base] = (row[exp_col], row[inf_col])
+    return out
+
+def gentle_gc_penalty(gc_val, gc_median, gc_iqr):
+    """
+    Very gentle penalty: near 1.0 for most of the range.
+    Uses robust z = |gc - median| / IQR.
+    Returns in [0.90, 1.00] (delicate gating).
+    """
+    if not np.isfinite(gc_val) or gc_iqr <= 1e-9 or not np.isfinite(gc_median):
+        return 1.0
+    z = abs(float(gc_val) - float(gc_median)) / float(gc_iqr)
+    pen = float(np.exp(-0.08 * z))
+    return float(min(1.0, max(0.90, pen)))
+
+def weight_for_supp2_genome(base, gc_percent, supp1_map, gc_median, gc_iqr):
+    """
+    Weight only for genomes in Supp2:
+      - STOP<->AA => very confident ALT signal (1.0)
+      - AA<->AA => confident, but apply gentle GC penalty (close to 1.0)
+      - STOP<->? treated like AA<->AA (your requirement)
+      - AA<->? => less confident (downweights with total_q)
+    If Supp1 missing or invalid: return 0.85 (still candidate but less trusted)
+    """
+    if base not in supp1_map:
+        return 0.85
+
+    exp, inf = supp1_map[base]
+    a = _analyze_expected_inferred(exp, inf)
+    if not a["valid"]:
+        return 0.85
+
+    aa_aa = a["aa_aa"]
+    aa_q = a["aa_q"]
+    stop_aa = a["stop_aa"]
+    stop_q = a["stop_q"]
+    total_q = a["total_q"]
+
+    gc_pen = gentle_gc_penalty(gc_percent, gc_median, gc_iqr)
+
+    if stop_aa > 0:
+        w = 1.00 * gc_pen
+        return float(max(0.90, min(1.00, w)))
+
+    # treat STOP<->? like AA<->AA
+    aa_like = aa_aa + stop_q
+
+    if aa_like > 0 and aa_q == 0:
+        w = 0.98 * gc_pen
+        return float(max(0.90, min(1.00, w)))
+
+    if aa_like > 0 and aa_q > 0:
+        w = 0.95 * (0.97 ** max(total_q, 0)) * gc_pen
+        return float(max(0.75, min(0.98, w)))
+
+    if aa_like == 0 and aa_q > 0:
+        w = 0.70 * (0.95 ** max(total_q, 0)) * gc_pen
+        return float(max(0.35, min(0.75, w)))
+
+    w = 0.80 * gc_pen
+    return float(max(0.50, min(0.90, w)))
+
+def build_sample_weights_for_dataset(meta_df, X_df, y_series, supp2_set, supp1_map):
+    """
+    Returns np.array weights (len == n_samples).
+    Only genomes in Supp2 get graded weights; others -> 1.0.
+    """
+    gc_vals = X_df["gc_percent"].astype(float).values if "gc_percent" in X_df.columns else np.full(len(X_df), np.nan)
+
+    gc_clean = gc_vals[np.isfinite(gc_vals)]
+    if gc_clean.size >= 10:
+        gc_median = float(np.median(gc_clean))
+        q1 = float(np.quantile(gc_clean, 0.25))
+        q3 = float(np.quantile(gc_clean, 0.75))
+        gc_iqr = float(max(1e-6, q3 - q1))
+    else:
+        gc_median, gc_iqr = float("nan"), 1.0
+
+    weights = np.ones(len(X_df), dtype=float)
+    bases = meta_df["acc_base"].astype(str).tolist()
+
+    for i, base in enumerate(bases):
+        if base in supp2_set:
+            gc = gc_vals[i]
+            weights[i] = weight_for_supp2_genome(base, gc, supp1_map, gc_median, gc_iqr)
+        else:
+            weights[i] = 1.0
+    return weights
+
+# =========================
+# Metrics utilities
+# =========================
+def metrics_from_pred(y_true, y_pred, y_proba=None):
+    y_true = np.asarray(y_true); y_pred = np.asarray(y_pred)
+    cm = confusion_matrix(y_true, y_pred, labels=[0,1])
+    tn, fp, fn, tp = int(cm[0,0]), int(cm[0,1]), int(cm[1,0]), int(cm[1,1])
+    row = dict(tn=tn, fp=fp, fn=fn, tp=tp)
+    row["n"] = int(len(y_true)); row["positives"] = int(y_true.sum())
+    row["accuracy"] = float(accuracy_score(y_true, y_pred))
+    row["precision"] = float(precision_score(y_true, y_pred, pos_label=1, zero_division=0))
+    row["recall"] = float(recall_score(y_true, y_pred, pos_label=1, zero_division=0))
+    row["specificity"] = float(tn / (tn + fp)) if (tn + fp) > 0 else 0.0
+    row["f1"] = float(f1_score(y_true, y_pred, pos_label=1, zero_division=0))
+    if y_proba is not None and not np.isnan(y_proba).all():
+        try: row["roc_auc"] = float(roc_auc_score(y_true, y_proba))
+        except Exception: row["roc_auc"] = float("nan")
+        try: row["pr_auc"] = float(average_precision_score(y_true, y_proba))
+        except Exception: row["pr_auc"] = float("nan")
+    else:
+        row["roc_auc"] = float("nan"); row["pr_auc"] = float("nan")
+    return row
+
+def best_threshold_f1(y_true, y_score):
+    p, r, t = precision_recall_curve(y_true, y_score)
+    f1 = (2*p*r) / np.maximum(p+r, 1e-12)
+    idx = int(np.nanargmax(f1))
+    return float(t[max(0, idx-1)]) if idx == len(t) else float(t[idx])
+
+def best_threshold_fbeta(y_true, y_score, beta=2.0):
+    p, r, t = precision_recall_curve(y_true, y_score)
+    if t.size == 0:
+        return float(np.median(y_score))
+    p = p[1:].astype(float)
+    r = r[1:].astype(float)
+    t = t.astype(float)
+    valid = np.isfinite(p) & np.isfinite(r) & np.isfinite(t)
+    p, r, t = p[valid], r[valid], t[valid]
+    if t.size == 0:
+        return float(np.median(y_score))
+    fbeta_vals = (1.0 + beta**2) * p * r / np.maximum(beta**2 * p + r, 1e-12)
+    j = int(np.nanargmax(fbeta_vals))
+    return float(t[j])
+
+# =========================
+# Optuna objective
+# =========================
+def make_objective(model_type: str,
+                   train_mode: str,
+                   X: pd.DataFrame, y: pd.Series, groups,
+                   metric_obj: str,
+                   n_splits: int, seed: int, threads: int,
+                   pu_bags: int, pu_u_ratio: float,
+                   fb_beta: float,
+                   sample_weight: np.ndarray | None):
+    sgkf = StratifiedGroupKFold(n_splits=n_splits, shuffle=True, random_state=seed)
+    pre = make_preprocess_pipeline(X)
+
+    def build_base_estimator(trial):
+        if model_type == "RF":
+            params = dict(
+                n_estimators = trial.suggest_int("n_estimators", 400, 1400),
+                max_depth    = trial.suggest_int("max_depth", 6, 16),
+                min_samples_split = trial.suggest_int("min_samples_split", 2, 20),
+                min_samples_leaf  = trial.suggest_int("min_samples_leaf", 2, 12),
+                max_features = trial.suggest_categorical("max_features", ["sqrt"]),
+                class_weight = trial.suggest_categorical("class_weight", [None, "balanced", "balanced_subsample"]),
+                n_jobs = threads,
+                random_state = seed,
+            )
+            return RandomForestClassifier(**params)
+
+        if model_type == "ET":
+            params = dict(
+                n_estimators = trial.suggest_int("n_estimators", 600, 2000),
+                max_depth    = trial.suggest_int("max_depth", 6, 18),
+                min_samples_split = trial.suggest_int("min_samples_split", 2, 20),
+                min_samples_leaf  = trial.suggest_int("min_samples_leaf", 2, 12),
+                max_features = trial.suggest_categorical("max_features", ["sqrt"]),
+                class_weight = trial.suggest_categorical("class_weight", [None, "balanced"]),
+                n_jobs = threads,
+                random_state = seed,
+            )
+            return ExtraTreesClassifier(**params)
+
+        if not _HAS_XGB:
+            raise RuntimeError("xgboost not installed")
+        params = dict(
+            n_estimators = trial.suggest_int("n_estimators", 400, 2000),
+            max_depth    = trial.suggest_int("max_depth", 3, 9),
+            learning_rate= trial.suggest_float("learning_rate", 1e-3, 0.15, log=True),
+            subsample    = trial.suggest_float("subsample", 0.6, 1.0),
+            colsample_bytree = trial.suggest_float("colsample_bytree", 0.5, 1.0),
+            reg_alpha    = trial.suggest_float("reg_alpha", 1e-4, 10.0, log=True),
+            reg_lambda   = trial.suggest_float("reg_lambda", 1e-3, 10.0, log=True),
+            gamma        = trial.suggest_float("gamma", 0.0, 5.0),
+            min_child_weight = trial.suggest_float("min_child_weight", 1e-3, 10.0, log=True),
+            n_jobs = threads,
+            random_state = seed,
+            tree_method = trial.suggest_categorical("tree_method", ["hist", "approx"]),
+            objective = "binary:logistic",
+            eval_metric = "logloss",
+        )
+        return XGBClassifier(**params)
+
+    def objective(trial):
+        clf = build_base_estimator(trial)
+        base_pipe = Pipeline([("pre", pre), ("clf", clf)])
+
+        if train_mode == "pu":
+            model = PUBaggingClassifier(
+                base_estimator=base_pipe,
+                n_bags=pu_bags,
+                u_ratio=pu_u_ratio,
+                random_state=seed
+            )
+        else:
+            model = base_pipe
+
+        y_true_all = []
+        proba_all = []
+        f_scores = []
+
+        for tr_idx, va_idx in sgkf.split(X, y, groups):
+            Xtr, Xva = X.iloc[tr_idx], X.iloc[va_idx]
+            ytr, yva = y.iloc[tr_idx], y.iloc[va_idx]
+
+            sw_tr = None
+            if sample_weight is not None:
+                sw_tr = np.asarray(sample_weight)[tr_idx]
+
+            model_fold = clone(model)
+            fit_pipeline(model_fold, Xtr, ytr, sw_tr)
+
+            proba = model_fold.predict_proba(Xva)[:, 1]
+            y_true_all.append(yva.values)
+            proba_all.append(proba)
+
+            if metric_obj == "F1":
+                thr = best_threshold_f1(yva.values, proba)
+                yhat = (proba >= thr).astype(int)
+                f_scores.append(f1_score(yva.values, yhat, zero_division=0))
+
+        y_true_all = np.concatenate(y_true_all)
+        proba_all = np.concatenate(proba_all)
+
+        if metric_obj == "F1":
+            return float(np.mean(f_scores))
+        if metric_obj == "PR_AUC":
+            return float(average_precision_score(y_true_all, proba_all))
+        if metric_obj == "FB":
+            thr = best_threshold_fbeta(y_true_all, proba_all, beta=fb_beta)
+            yhat = (proba_all >= thr).astype(int)
+            return float(fbeta_score(y_true_all, yhat, beta=fb_beta, zero_division=0))
+
+        raise ValueError("metric_obj must be one of: F1, PR_AUC, FB")
+
+    return objective, pre
+
+# =========================
+# Fit best model + calibration + threshold + test metrics
+# =========================
+def fit_best_model(model_type: str,
+                   train_mode: str,
+                   weight_mode: str,
+                   metric_obj: str,
+                   X: pd.DataFrame, y: pd.Series, groups,
+                   seed: int, timeout: int, n_trials: int, outdir: Path, tag: str,
+                   X_test: pd.DataFrame = None, y_test: pd.Series = None,
+                   threads: int = 1,
+                   pu_bags: int = 15, pu_u_ratio: float = 3.0,
+                   fb_beta: float = 2.0,
+                   calibrate: bool = True,
+                   sample_weight: np.ndarray | None = None,
+                   cv_folds: int = 5):
+
+    t0 = time.time()
+
+    def _make_eta_cb(t0, timeout, n_trials):
+        def _cb(study, trial):
+            try:
+                elapsed = time.time() - t0
+                done = trial.number + 1
+                avg = elapsed / max(1, done)
+                rem_trials = max(0, (n_trials or 0) - done)
+                eta_trials = rem_trials * avg if n_trials else float('inf')
+                eta_timeout = max(0.0, (timeout or 0) - elapsed) if timeout else float('inf')
+                eta = min(eta_trials, eta_timeout)
+                print(f"[TRIAL] #{trial.number:03d} value={trial.value:.5f} | best={study.best_value:.5f} | elapsed={elapsed/60:.1f}m | ETA~{eta/60:.1f}m")
+            except Exception:
+                print(f"[TRIAL] #{trial.number:03d} done")
+        return _cb
+
+    study = optuna.create_study(
+        direction="maximize",
+        pruner=MedianPruner(n_startup_trials=8, n_warmup_steps=2),
+        study_name=f"{model_type}_{train_mode}_{weight_mode}_{metric_obj}_{tag}"
+    )
+
+    objective, pre = make_objective(
+        model_type=model_type,
+        train_mode=train_mode,
+        X=X, y=y, groups=groups,
+        metric_obj=metric_obj,
+        n_splits=cv_folds,
+        seed=seed, threads=threads,
+        pu_bags=pu_bags, pu_u_ratio=pu_u_ratio,
+        fb_beta=fb_beta,
+        sample_weight=sample_weight
+    )
+
+    study.optimize(
+        objective,
+        timeout=timeout,
+        n_trials=n_trials,
+        gc_after_trial=True,
+        callbacks=[_make_eta_cb(t0, timeout, n_trials)]
+    )
+
+    best_params = dict(study.best_params)
+
+    # rebuild best estimator
+    if model_type == "RF":
+        clf = RandomForestClassifier(**{**best_params, "n_jobs": threads, "random_state": seed})
+    elif model_type == "ET":
+        clf = ExtraTreesClassifier(**{**best_params, "n_jobs": threads, "random_state": seed})
+    else:
+        if not _HAS_XGB:
+            raise RuntimeError("xgboost not installed")
+        clf = XGBClassifier(**{
+            **best_params,
+            "n_jobs": threads,
+            "random_state": seed,
+            "objective": "binary:logistic",
+            "eval_metric": "logloss",
+        })
+
+    base_pipe = Pipeline([("pre", pre), ("clf", clf)])
+
+    if train_mode == "pu":
+        model = PUBaggingClassifier(
+            base_estimator=base_pipe,
+            n_bags=pu_bags,
+            u_ratio=pu_u_ratio,
+            random_state=seed
+        )
+    else:
+        model = base_pipe
+
+    # fit final model (weighted or not)
+    fit_pipeline(model, X, y, sample_weight)
+
+    # optional calibration
+    final_model = model
+    if calibrate:
+        # CalibratedClassifierCV will refit the estimator cv times; for PU this is heavy.
+        try:
+            calib = CalibratedClassifierCV(estimator=model, method="isotonic", cv=cv_folds)
+        except TypeError:
+            calib = CalibratedClassifierCV(base_estimator=model, method="isotonic", cv=cv_folds)
+
+        # We avoid passing weights here for robustness across sklearn versions.
+        calib.fit(X, y)
+        final_model = calib
+
+    # threshold selection on train
+    proba_tr = final_model.predict_proba(X)[:, 1]
+    if metric_obj == "F1":
+        tau = best_threshold_f1(y.values, proba_tr)
+    elif metric_obj == "FB":
+        tau = best_threshold_fbeta(y.values, proba_tr, beta=fb_beta)
+    else:
+        tau = best_threshold_f1(y.values, proba_tr)
+
+    yhat_tr = (proba_tr >= tau).astype(int)
+    train_row = metrics_from_pred(y.values, yhat_tr, proba_tr)
+    train_row = {f"train_{k}": v for k, v in train_row.items()}
+
+    metrics = dict(
+        threshold_used=float(tau),
+        study_best=float(study.best_value),
+        model_type=model_type,
+        train_mode=train_mode,
+        weight_mode=weight_mode,
+        metric_obj=metric_obj,
+        fb_beta=float(fb_beta),
+        pu_bags=int(pu_bags),
+        pu_u_ratio=float(pu_u_ratio),
+        calibrated=bool(calibrate),
+        **train_row
+    )
+
+    # test metrics (always)
+    if X_test is not None and y_test is not None:
+        X_te = X_test.reindex(columns=list(X.columns))
+        proba_te = final_model.predict_proba(X_te)[:, 1]
+        yhat_te = (proba_te >= tau).astype(int)
+        test_row = metrics_from_pred(y_test.values, yhat_te, proba_te)
+        metrics.update({f"test_{k}": v for k, v in test_row.items()})
+
+    return final_model, best_params, metrics, study
+
+# =========================
+# Results folder detection / skipping already trained variants
+# =========================
+def model_run_id(model_type, train_mode, weight_mode, metric_obj, tag):
+    return f"{model_type}_{train_mode}_{weight_mode}_{metric_obj}_{tag}"
+
+def artifact_paths(results_dir: Path, run_id: str):
+    return {
+        "model":   results_dir / f"model_{run_id}.joblib",
+        "params":  results_dir / f"best_params_{run_id}.json",
+        "metrics": results_dir / f"metrics_{run_id}.json",
+    }
+
+def is_run_complete(results_dir: Path, run_id: str) -> bool:
+    p = artifact_paths(results_dir, run_id)
+    return p["model"].exists() and p["metrics"].exists() and p["params"].exists()
+
+def load_existing_metrics(results_dir: Path) -> list:
+    rows = []
+    for mf in sorted(results_dir.glob("metrics_*.json")):
+        try:
+            d = json.loads(mf.read_text())
+            rows.append(d)
+        except Exception:
+            continue
+    return rows
+
+def append_metrics_summary(results_dir: Path, rows: list):
+    if not rows:
+        return
+    df = pd.DataFrame(rows)
+    df.to_csv(results_dir / "metrics_summary.csv", index=False)
+
+# =========================
+# Main
+# =========================
+def main():
+    ap = argparse.ArgumentParser(description="Train RF/XGB/ET with grouped CV. supervised + PU. normal + weighted.")
+    ap.add_argument("--ndjson", required=True, help="Folder with train.jsonl and test.jsonl")
+    ap.add_argument("--supp2", required=True, help="Supp2.xlsx (positives list for PU; label=1)")
+    ap.add_argument("--supp1", required=False, default=None, help="Supp1.csv (for weighted grading of Supp2 genomes)")
+    ap.add_argument("--outdir", required=True, help="Output directory root (will create results_models/)")
+
+    ap.add_argument("--train_mode", choices=["supervised","pu","both"], default="both",
+                    help="Training mode: classic supervised vs PU-bagging vs both")
+
+    ap.add_argument("--weight_mode", choices=["normal","weighted","both"], default="both",
+                    help="normal: all weights=1; weighted: grade only Supp2 genomes via Supp1 expected/inferred; both: run both")
+
+    ap.add_argument("--model", choices=["RF","XGB","ET","all"], default="all",
+                    help="Model(s): RF, XGB, ET (ExtraTrees baseline), or all")
+
+    ap.add_argument("--metric", choices=["F1","PR_AUC","FB","all"], default="all",
+                    help="Optuna objective metric")
+
+    ap.add_argument("--fb_beta", type=float, default=2.0, help="Beta for F-beta metric (FB objective)")
+
+    ap.add_argument("--timeout", type=int, default=3600, help="Optuna time budget per run (seconds)")
+    ap.add_argument("--n_trials", type=int, default=60, help="Upper limit of trials if timeout not reached")
+    ap.add_argument("--threads", type=int, default=0, help="Threads (0=auto cpu_count()-4)")
+    ap.add_argument("--seed", type=int, default=42, help="Random seed")
+
+    ap.add_argument("--pu_bags", type=int, default=15, help="PU bagging: number of bags")
+    ap.add_argument("--pu_u_ratio", type=float, default=3.0, help="PU bagging: U sampled per bag = ratio * |P|")
+
+    ap.add_argument("--no_calibration", action="store_true",
+                    help="Disable isotonic calibration (use raw predict_proba from base model / PU ensemble).")
+
+    ap.add_argument("--force_calibration_pu", action="store_true",
+                    help="Force calibration even for PU (can be extremely slow: cv_folds * pu_bags fits).")
+
+    ap.add_argument("--cv", type=int, default=5, help="Grouped CV folds for objective & calibration")
+    ap.add_argument("--overwrite", action="store_true",
+                    help="Re-train even if artifacts already exist for a run_id (otherwise skipped).")
+
+    args = ap.parse_args()
+
+    cpu_total = os.cpu_count() or 8
+    eff_threads = max(1, cpu_total - 4) if args.threads in (None, 0, -1) else max(1, args.threads)
+    print(f"[CPU ] total={cpu_total} using={eff_threads} (flag={args.threads})")
+
+    os.environ['OMP_NUM_THREADS'] = str(eff_threads)
+    os.environ['OPENBLAS_NUM_THREADS'] = str(eff_threads)
+    os.environ['MKL_NUM_THREADS'] = str(eff_threads)
+    os.environ['VECLIB_MAXIMUM_THREADS'] = str(eff_threads)
+    os.environ['NUMEXPR_NUM_THREADS'] = str(eff_threads)
+
+    out_root = Path(args.outdir)
+    out_root.mkdir(parents=True, exist_ok=True)
+
+    results_dir = out_root / "results_models"
+    results_dir.mkdir(parents=True, exist_ok=True)
+
+    # load once
+    Xtr, ytr, gtr, mtr, Xte, yte, gte, mte = _load_train_test(args.ndjson, args.supp2)
+    tag = "64log_gc_tetra"
+
+    supp2_set = load_alt_list_from_supp2(args.supp2)
+
+    # weights (only if needed)
+    supp1_map = {}
+    if args.supp1:
+        print("[LOAD] Supp1 mapping for weights:", args.supp1)
+        supp1_map = load_supp1_code_map(args.supp1)
+
+    weights_train_weighted = None
+    weights_test_weighted = None
+    if args.weight_mode in ("weighted", "both"):
+        if not args.supp1:
+            raise ValueError("--weight_mode weighted/both requires --supp1 Supp1.csv")
+        weights_train_weighted = build_sample_weights_for_dataset(mtr, Xtr, ytr, supp2_set, supp1_map)
+        weights_test_weighted  = build_sample_weights_for_dataset(mte, Xte, yte, supp2_set, supp1_map)
+
+        # snapshot for debugging
+        snap_tr = pd.DataFrame({
+            "acc_base": mtr["acc_base"].astype(str).values,
+            "y": ytr.astype(int).values,
+            "gc_percent": Xtr["gc_percent"].astype(float).values,
+            "weight": weights_train_weighted
+        })
+        snap_te = pd.DataFrame({
+            "acc_base": mte["acc_base"].astype(str).values,
+            "y": yte.astype(int).values,
+            "gc_percent": Xte["gc_percent"].astype(float).values,
+            "weight": weights_test_weighted
+        })
+        snap_tr.to_csv(results_dir / "weights_snapshot_train.tsv", sep="\t", index=False)
+        snap_te.to_csv(results_dir / "weights_snapshot_test.tsv", sep="\t", index=False)
+        print("[WRITE] weights_snapshot_train.tsv / weights_snapshot_test.tsv")
+
+        wP = weights_train_weighted[ytr.values == 1]
+        if wP.size:
+            print(f"[WEIGHTS] Supp2(P) weights: n={wP.size} mean={wP.mean():.3f} sd={wP.std():.3f} min={wP.min():.3f} max={wP.max():.3f}")
+
+    print("\n" + "="*72)
+    print(f"[DATA] train={Xtr.shape} P(from Supp2)={int(ytr.sum())} ({100.0*float(ytr.mean()):.3f}%)")
+    print(f"[DATA]  test={Xte.shape} P(from Supp2)={int(yte.sum())} ({100.0*float(yte.mean()):.3f}%)")
+    print("="*72)
+
+    train_modes = ["supervised","pu"] if args.train_mode == "both" else [args.train_mode]
+    weight_modes = ["normal","weighted"] if args.weight_mode == "both" else [args.weight_mode]
+    models = ["RF","XGB","ET"] if args.model == "all" else [args.model]
+    metrics = ["F1","PR_AUC","FB"] if args.metric == "all" else [args.metric]
+
+    # Load any already-existing metrics into summary rows
+    global_rows = load_existing_metrics(results_dir)
+    if global_rows:
+        append_metrics_summary(results_dir, global_rows)
+        print(f"[INFO] Found existing metrics: {len(global_rows)} runs. metrics_summary.csv refreshed.")
+
+    for tm in train_modes:
+        for wm in weight_modes:
+            for met in metrics:
+                for mdl in models:
+                    run_id = model_run_id(mdl, tm, wm, met, tag)
+
+                    # Decide calibration: PU default off unless forced
+                    calibrate = (not args.no_calibration)
+                    if tm == "pu" and calibrate and not args.force_calibration_pu:
+                        print(f"[INFO] Auto-disabling calibration for PU run {run_id} (use --force_calibration_pu to override).")
+                        calibrate = False
+
+                    # Skip if complete and not overwrite
+                    if (not args.overwrite) and is_run_complete(results_dir, run_id):
+                        print(f"[SKIP] already exists: {run_id}")
+                        continue
+
+                    print("\n" + "-"*72)
+                    print(f"[RUN ] mode={tm} | weights={wm} | metric={met} | model={mdl} | timeout={args.timeout}s | trials={args.n_trials}")
+                    print(f"[RUN ] run_id={run_id} | calibrate={calibrate}")
+                    print("-"*72)
+
+                    # pick weights
+                    if wm == "weighted":
+                        sw_tr = weights_train_weighted
+                        sw_te = weights_test_weighted
+                    else:
+                        sw_tr = None
+                        sw_te = None
+
+                    t0 = time.time()
+                    final_model, best_params, met_dict, study = fit_best_model(
+                        model_type=mdl,
+                        train_mode=tm,
+                        weight_mode=wm,
+                        metric_obj=met,
+                        X=Xtr, y=ytr, groups=gtr,
+                        seed=args.seed,
+                        timeout=args.timeout,
+                        n_trials=args.n_trials,
+                        outdir=results_dir,
+                        tag=tag,
+                        X_test=Xte,
+                        y_test=yte,
+                        threads=eff_threads,
+                        pu_bags=args.pu_bags,
+                        pu_u_ratio=args.pu_u_ratio,
+                        fb_beta=args.fb_beta,
+                        calibrate=calibrate,
+                        sample_weight=sw_tr,
+                        cv_folds=args.cv
+                    )
+
+                    dt = time.time() - t0
+                    print(f"[DONE] {mdl} | {tm} | {wm} | {met} in {dt/60:.1f} min best={study.best_value:.5f}")
+
+                    # crash-safe save immediately
+                    model_path   = results_dir / f"model_{run_id}.joblib"
+                    params_path  = results_dir / f"best_params_{run_id}.json"
+                    metrics_path = results_dir / f"metrics_{run_id}.json"
+                    cols_path    = results_dir / f"feature_columns_{tag}.json"
+
+                    joblib.dump(final_model, model_path)
+                    params_path.write_text(json.dumps(best_params, indent=2))
+                    metrics_path.write_text(json.dumps(met_dict, indent=2))
+                    if not cols_path.exists():
+                        cols_path.write_text(json.dumps(list(Xtr.columns), indent=2))
+
+                    # Update in-memory summary list:
+                    # remove previous row with same run_id if overwrite
+                    global_rows = [r for r in global_rows if not (
+                        r.get("model_type")==mdl and r.get("train_mode")==tm and r.get("weight_mode")==wm
+                        and r.get("metric_obj")==met
+                    )]
+                    met_row = dict(met_dict)
+                    met_row["elapsed_min"] = float(dt/60.0)
+                    global_rows.append(met_row)
+
+                    append_metrics_summary(results_dir, global_rows)
+                    print("[WRITE] metrics_summary.csv updated")
+
+    print("[DONE] Saved artifacts to", results_dir.resolve())
+
+if __name__ == "__main__":
+    main()
+

Supp1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a812e57415028390f2839a6ec89e3023c29545a6dbe7c03d0498b83fe6640fc
+size 51347196

Supp2.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47567efc7b4b09f753d131f8c229e1d89087a03b2ce8b2f92d3226be8e6f8b11
+size 2186240

metrics_summary.csv

@@ -0,0 +1,10 @@
+threshold_used,study_best,model_type,train_mode,weight_mode,metric_obj,fb_beta,pu_bags,pu_u_ratio,calibrated,train_tn,train_fp,train_fn,train_tp,train_n,train_positives,train_accuracy,train_precision,train_recall,train_specificity,train_f1,train_roc_auc,train_pr_auc,test_tn,test_fp,test_fn,test_tp,test_n,test_positives,test_accuracy,test_precision,test_recall,test_specificity,test_f1,test_roc_auc,test_pr_auc,elapsed_min
+0.28160005812047,0.7170877819106146,RF,supervised,weighted,F1,2.0,15,3.0,True,192327,599,1445,3845,198216,5290,0.9896880171126448,0.8652115211521152,0.7268431001890359,0.996895182608876,0.7900143825765359,0.989440669602949,0.8648721301935423,47948,223,516,868,49555,1384,0.9850872767631924,0.7956003666361137,0.6271676300578035,0.9953706586950655,0.7014141414141414,0.9417760493895602,0.7089960012695522,100.32298675378163
+0.270977745577693,0.7316308621469358,XGB,supervised,weighted,F1,2.0,15,3.0,True,192282,644,1329,3961,198216,5290,0.9900462122129394,0.8601520086862107,0.7487712665406427,0.9966619325544509,0.8006063668519454,0.9912934246099276,0.8724422883868594,47958,213,489,895,49555,1384,0.9858339219049541,0.8077617328519856,0.6466763005780347,0.9955782524755559,0.7182985553772071,0.9480600136219919,0.7391698893672186,116.04822653134664
+0.26884064330614116,0.7142723913988928,ET,supervised,weighted,F1,2.0,15,3.0,True,192018,908,1096,4194,198216,5290,0.9898898171691488,0.82203057624461,0.7928166351606806,0.9952935322351575,0.8071593533487298,0.9957403224449537,0.8900330617078354,47854,317,481,903,49555,1384,0.9838966804560589,0.7401639344262295,0.6524566473988439,0.9934192771584563,0.6935483870967742,0.947862627035694,0.7126230593189249,95.2558631738027
+0.3056620102323837,0.7323725486714675,RF,supervised,weighted,PR_AUC,2.0,15,3.0,True,192450,476,1429,3861,198216,5290,0.9903892723089962,0.8902467143186534,0.729867674858223,0.9975327327576377,0.802119040199439,0.9904682181539894,0.8741500528850537,47969,202,524,860,49555,1384,0.9853496115427303,0.8097928436911488,0.6213872832369942,0.9958066056340952,0.7031888798037612,0.9405524235493905,0.7071107938720944,109.88682698011398
+0.2763037309981883,0.7739642015387473,XGB,supervised,weighted,PR_AUC,2.0,15,3.0,True,192350,576,837,4453,198216,5290,0.9928714130039956,0.8854643070192881,0.8417769376181474,0.9970143993033599,0.8630681267564686,0.9954336537391821,0.9287123546097,47936,235,445,939,49555,1384,0.9862778730703259,0.7998296422487223,0.6784682080924855,0.9951215461584771,0.7341673182173573,0.9540925553870405,0.7605201702162149,129.1129001100858
+0.2528274437858936,0.733124843786015,ET,supervised,weighted,PR_AUC,2.0,15,3.0,True,191998,928,1001,4289,198216,5290,0.9902681922750939,0.8221199923327583,0.8107750472589792,0.995189865544302,0.8164081088797944,0.9960269471274596,0.8960748662603205,47833,338,480,904,49555,1384,0.9834930884875391,0.7278582930756844,0.653179190751445,0.9929833302194266,0.6884996191926885,0.9482122815600444,0.714426289534482,98.56812449296315
+0.22519098961318726,0.7034497459764806,RF,supervised,weighted,FB,2.0,15,3.0,True,191371,1555,136,5154,198216,5290,0.9914689026112927,0.7682217916231927,0.9742911153119093,0.9919399147859801,0.8590715892991082,0.9978907399914563,0.9084804543955299,47725,446,432,952,49555,1384,0.9822823125819796,0.6809728183118741,0.6878612716763006,0.9907413173901309,0.6843997124370956,0.9534422648697445,0.7103612744548206,103.77016698916754
+0.3765930473804474,0.7424014112977324,XGB,supervised,weighted,FB,2.0,15,3.0,True,192750,176,41,5249,198216,5290,0.9989052346934657,0.9675576036866359,0.9922495274102079,0.999087733120471,0.9797480167988801,0.9998785149842558,0.9948955292297433,48029,142,472,912,49555,1384,0.9876097265664413,0.8652751423149905,0.6589595375722543,0.9970521683170372,0.7481542247744053,0.9543304332602195,0.7737554628839785,142.53574102719625
+0.1603667577708411,0.7068965517241379,ET,supervised,weighted,FB,2.0,15,3.0,True,191735,1191,425,4865,198216,5290,0.9918472777172378,0.803335535006605,0.9196597353497165,0.9938266485595514,0.8575709501145778,0.997956241564711,0.9410532422004124,47683,488,403,981,49555,1384,0.9820199778024418,0.6678012253233492,0.7088150289017341,0.9898694235120716,0.6876971608832808,0.9484654214759726,0.7242309832041485,96.69467223485312

predict_dir.py

@@ -0,0 +1,557 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+predict_models_dir_with_truth.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).
+
+Ground truth:
+  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)
+
+Wymaga: aragorn w PATH (lub --aragorn).
+"""
+
+import os
+import re
+import json
+import time
+import argparse
+import subprocess
+from pathlib import Path
+from collections import Counter
+
+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,
+    precision_score,
+    recall_score,
+    f1_score,
+    roc_auc_score,
+    average_precision_score,
+)
+
+# =========================
+# 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
+        self.n_bags = int(n_bags)
+        self.u_ratio = float(u_ratio)
+        self.random_state = int(random_state)
+        self.models_ = None
+        self.classes_ = np.array([0, 1], dtype=int)
+
+    def fit(self, X, y, sample_weight=None):
+        y = np.asarray(y).astype(int)
+        pos_idx = np.where(y == 1)[0]
+        unl_idx = np.where(y == 0)[0]
+        if pos_idx.size == 0:
+            raise ValueError("PU training requires at least one positive sample (y==1).")
+
+        rng = np.random.RandomState(self.random_state)
+        self.models_ = []
+
+        if unl_idx.size == 0:
+            m = clone(self.base_estimator)
+            try:
+                if sample_weight is not None:
+                    m.fit(X, y, sample_weight=np.asarray(sample_weight))
+                else:
+                    m.fit(X, y)
+            except TypeError:
+                m.fit(X, y)
+            self.models_.append(m)
+            return self
+
+        k_u = int(min(unl_idx.size, max(1, round(self.u_ratio * pos_idx.size))))
+        for _ in range(self.n_bags):
+            u_b = rng.choice(unl_idx, size=k_u, replace=(k_u > unl_idx.size))
+            idx_b = np.concatenate([pos_idx, u_b])
+            X_b = X.iloc[idx_b] if hasattr(X, "iloc") else X[idx_b]
+            y_b = y[idx_b]
+
+            sw_b = None
+            if sample_weight is not None:
+                sw_b = np.asarray(sample_weight)[idx_b]
+
+            m = clone(self.base_estimator)
+            try:
+                if sw_b is not None:
+                    m.fit(X_b, y_b, sample_weight=sw_b)
+                else:
+                    m.fit(X_b, y_b)
+            except TypeError:
+                m.fit(X_b, y_b)
+
+            self.models_.append(m)
+        return self
+
+    def predict_proba(self, X):
+        if not self.models_:
+            raise RuntimeError("PUBaggingClassifier not fitted")
+        probs = [m.predict_proba(X) for m in self.models_]
+        return np.mean(np.stack(probs, axis=0), axis=0)
+
+    def predict(self, X):
+        return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)
+
+
+# =========================
+# Feature extraction
+# =========================
+CODON_RE = re.compile(r"\(([ACGTUacgtu]{3})\)")
+
+def set_single_thread_env():
+    os.environ["OMP_NUM_THREADS"] = "1"
+    os.environ["OPENBLAS_NUM_THREADS"] = "1"
+    os.environ["MKL_NUM_THREADS"] = "1"
+    os.environ["VECLIB_MAXIMUM_THREADS"] = "1"
+    os.environ["NUMEXPR_NUM_THREADS"] = "1"
+
+def list_fasta_files(genomes_dir: str):
+    exts = (".fna", ".fa", ".fasta")
+    paths = []
+    for fn in os.listdir(genomes_dir):
+        p = os.path.join(genomes_dir, fn)
+        if not os.path.isfile(p):
+            continue
+        if fn.endswith(exts):
+            paths.append(p)
+    return sorted(paths)
+
+def calc_gc_and_tetra(fasta_path):
+    bases = ["A", "C", "G", "T"]
+    all_kmers = ["".join([a, b, c, d]) for a in bases for b in bases for c in bases for d in bases]
+    tetra_counts = {k: 0 for k in all_kmers}
+
+    A = C = G = T = 0
+    tail = ""
+
+    with open(fasta_path, "r") as fh:
+        for line in fh:
+            if line.startswith(">"):
+                continue
+            s = line.strip().upper().replace("U", "T")
+            s = re.sub(r"[^ACGT]", "N", s)
+            if not s:
+                continue
+
+            seq = tail + s
+
+            for ch in s:
+                if ch == "A": A += 1
+                elif ch == "C": C += 1
+                elif ch == "G": G += 1
+                elif ch == "T": T += 1
+
+            for i in range(len(seq) - 3):
+                k = seq[i:i+4]
+                if "N" in k:
+                    continue
+                tetra_counts[k] += 1
+
+            tail = seq[-3:] if len(seq) >= 3 else seq
+
+    total_acgt = A + C + G + T
+    gc_percent = (float(G + C) / float(total_acgt) * 100.0) if total_acgt > 0 else 0.0
+
+    windows_total = sum(tetra_counts.values())
+    denom = float(windows_total) if windows_total > 0 else 1.0
+    tetra_freq = {f"tetra_{k}": float(v) / denom for k, v in tetra_counts.items()}
+
+    features = {
+        "gc_percent": float(gc_percent),
+        "genome_length": float(total_acgt),
+    }
+    features.update(tetra_freq)
+    return features
+
+def run_aragorn(aragorn_bin, fasta_path, out_txt):
+    cmd = [aragorn_bin, "-t", "-l", "-gc1", "-w", "-o", out_txt, fasta_path]
+    with open(os.devnull, "w") as devnull:
+        subprocess.run(cmd, stdout=devnull, stderr=devnull, check=False)
+
+def parse_anticodons_from_aragorn(aragorn_txt):
+    counts = Counter()
+    if not os.path.isfile(aragorn_txt):
+        return counts
+    with open(aragorn_txt, "r") as fh:
+        for line in fh:
+            for m in CODON_RE.finditer(line):
+                cod = m.group(1).upper().replace("U", "T")
+                if re.fullmatch(r"[ACGT]{3}", cod):
+                    counts[cod] += 1
+    return counts
+
+def build_ac_features(anticodon_counts):
+    bases = ["A", "C", "G", "T"]
+    feats = {}
+    for a in bases:
+        for b in bases:
+            for c in bases:
+                cod = f"{a}{b}{c}"
+                feats[f"ac_{cod}"] = float(anticodon_counts.get(cod, 0))
+    return feats
+
+def build_plr_features(ac_features, needed_plr_cols, eps=0.5):
+    plr_feats = {}
+    for col in needed_plr_cols:
+        core = col[len("plr_"):]
+        left, right = core.split("__")
+        a = ac_features.get(f"ac_{left}", 0.0)
+        b = ac_features.get(f"ac_{right}", 0.0)
+        plr_feats[col] = float(np.log((a + eps) / (b + eps)))
+    return plr_feats
+
+def build_features_for_genome(fasta_path, aragorn_bin, feature_columns, reuse_aragorn=True):
+    acc = os.path.splitext(os.path.basename(fasta_path))[0]
+
+    feat_gc_tetra = calc_gc_and_tetra(fasta_path)
+
+    tmp_aragorn = fasta_path + ".aragorn.txt"
+    if reuse_aragorn and os.path.isfile(tmp_aragorn):
+        try:
+            if os.path.getmtime(tmp_aragorn) < os.path.getmtime(fasta_path):
+                run_aragorn(aragorn_bin, fasta_path, tmp_aragorn)
+        except Exception:
+            run_aragorn(aragorn_bin, fasta_path, tmp_aragorn)
+    else:
+        run_aragorn(aragorn_bin, fasta_path, tmp_aragorn)
+
+    anticodon_counts = parse_anticodons_from_aragorn(tmp_aragorn)
+    ac_feats = build_ac_features(anticodon_counts)
+
+    plr_cols = [c for c in feature_columns if c.startswith("plr_")]
+    plr_feats = build_plr_features(ac_feats, plr_cols) if plr_cols else {}
+
+    all_feats = {}
+    all_feats.update(ac_feats)
+    all_feats.update(plr_feats)
+    all_feats.update(feat_gc_tetra)
+
+    row = {col: float(all_feats.get(col, 0.0)) for col in feature_columns}
+    return acc, row
+
+
+# =========================
+# Ground truth from TSV
+# =========================
+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)}")
+
+    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
+    df["y_true_alt"] = df["Genetic_code_ID"].apply(lambda x: (pd.notna(x) and int(x) != 11)).astype(int)
+    df["true_label"] = df["y_true_alt"].map({0: "STD", 1: "ALT"})
+
+    return df[["Genome", "Genome_type", "Genetic_code_ID", "y_true_alt", "true_label"]]
+
+
+# =========================
+# Metrics
+# =========================
+def safe_confusion(y_true, y_pred):
+    cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
+    tn, fp, fn, tp = int(cm[0,0]), int(cm[0,1]), int(cm[1,0]), int(cm[1,1])
+    return tn, fp, fn, tp
+
+def compute_metrics_block(y_true, y_pred, y_score=None):
+    y_true = np.asarray(y_true, dtype=int)
+    y_pred = np.asarray(y_pred, dtype=int)
+
+    tn, fp, fn, tp = safe_confusion(y_true, y_pred)
+    n = int(len(y_true))
+    pos = int(np.sum(y_true == 1))
+
+    out = {
+        "n": n,
+        "positives": pos,
+        "tn": tn, "fp": fp, "fn": fn, "tp": tp,
+        "accuracy": float(accuracy_score(y_true, y_pred)) if n else np.nan,
+        "precision": float(precision_score(y_true, y_pred, zero_division=0)) if n else np.nan,
+        "recall": float(recall_score(y_true, y_pred, zero_division=0)) if n else np.nan,
+        "f1": float(f1_score(y_true, y_pred, zero_division=0)) if n else np.nan,
+        "specificity": float(tn / (tn + fp)) if (tn + fp) > 0 else np.nan,
+        "fn_rate": float(fn / (fn + tp)) if (fn + tp) > 0 else np.nan,   # 1 - recall
+        "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:
+            try:
+                out["roc_auc"] = float(roc_auc_score(y_true, y_score))
+            except Exception:
+                out["roc_auc"] = np.nan
+            try:
+                out["pr_auc"] = float(average_precision_score(y_true, y_score))
+            except Exception:
+                out["pr_auc"] = np.nan
+        else:
+            out["roc_auc"] = np.nan
+            out["pr_auc"] = np.nan
+    else:
+        out["roc_auc"] = np.nan
+        out["pr_auc"] = np.nan
+
+    return out
+
+
+# =========================
+# Model discovery
+# =========================
+def find_models(models_dir: Path):
+    return sorted(models_dir.glob("model_*.joblib"))
+
+def pick_feature_cols(models_dir: Path, feature_cols_arg: str | None):
+    if feature_cols_arg:
+        return Path(feature_cols_arg)
+    p = models_dir / "feature_columns_64log_gc_tetra.json"
+    if p.exists():
+        return p
+    candidates = sorted(models_dir.glob("feature_columns_*.json"))
+    if not candidates:
+        raise FileNotFoundError(f"No feature_columns_*.json found in {models_dir}")
+    return candidates[0]
+
+
+# =========================
+# 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")
+    args = ap.parse_args()
+
+    set_single_thread_env()
+
+    genomes_dir = Path(args.genomes_dir)
+    models_dir = Path(args.models_dir)
+    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}")
+
+    models = find_models(models_dir)
+    if not models:
+        raise SystemExit(f"Brak model_*.joblib w {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] FeatCols: {feat_cols_path}")
+
+    # Load feature columns
+    with open(feat_cols_path, "r") as fh:
+        feature_columns = json.load(fh)
+
+    # Build features once (shared across all models)
+    t_feat0 = time.time()
+    rows, accs = [], []
+    for i, fasta in enumerate(fasta_files, 1):
+        if i % 50 == 0 or i == 1 or i == len(fasta_files):
+            print(f"[FEAT] {i}/{len(fasta_files)} {os.path.basename(fasta)}")
+        acc, feats = build_features_for_genome(
+            fasta_path=fasta,
+            aragorn_bin=args.aragorn,
+            feature_columns=feature_columns,
+            reuse_aragorn=args.reuse_aragorn
+        )
+        accs.append(acc)
+        rows.append(feats)
+
+    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}")
+
+    # Prepare outputs
+    long_rows = []
+    summary_rows = []
+
+    for mi, model_path in enumerate(models, 1):
+        model_name = model_path.stem
+        print("\n" + "="*80)
+        print(f"[{mi}/{len(models)}] MODEL: {model_path.name}")
+        print("="*80)
+
+        t0 = time.time()
+        model = joblib_load(model_path)
+
+        if hasattr(model, "predict_proba"):
+            proba = model.predict_proba(X)[:, 1]
+        else:
+            proba = None
+
+        if hasattr(model, "predict"):
+            try:
+                yhat = model.predict(X)
+            except Exception:
+                yhat = (proba >= 0.5).astype(int) if proba is not None else np.zeros(len(X), dtype=int)
+        else:
+            yhat = (proba >= 0.5).astype(int) if proba is not None else np.zeros(len(X), dtype=int)
+
+        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
+
+        out_csv = outdir / f"{model_name}__pred.csv"
+        df_pred.to_csv(out_csv, index=False)
+        print(f"[WRITE] {out_csv} rows={len(df_pred)} time={(elapsed/60):.2f} min")
+
+        # 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)
+
+    # 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)
+
+    print("[DONE]")
+
+if __name__ == "__main__":
+    main()
+

predictions_truth/all_models_predictions_long.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1ff896223d03dfb2a08d11ea69a938e07df40d496235f7e794b4d0382471419
+size 15681101

predictions_truth/prediction_summary.csv

@@ -0,0 +1,37 @@
+model,model_file,feature_cols,n_genomes_total,n_annotated,n_missing_truth,elapsed_sec,elapsed_min,overall_n,overall_positives,overall_tn,overall_fp,overall_fn,overall_tp,overall_accuracy,overall_precision,overall_recall,overall_f1,overall_specificity,overall_fn_rate,overall_fp_rate,overall_roc_auc,overall_pr_auc,isolate_n,isolate_positives,isolate_tn,isolate_fp,isolate_fn,isolate_tp,isolate_accuracy,isolate_precision,isolate_recall,isolate_f1,isolate_specificity,isolate_fn_rate,isolate_fp_rate,isolate_roc_auc,isolate_pr_auc,mag_n,mag_positives,mag_tn,mag_fp,mag_fn,mag_tp,mag_accuracy,mag_precision,mag_recall,mag_f1,mag_specificity,mag_fn_rate,mag_fp_rate,mag_roc_auc,mag_pr_auc
+model_ET_pu_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,50.55208730697632,0.8425347884496053,4728,71,4596,61,36,35,0.9794839255499154,0.3645833333333333,0.49295774647887325,0.41916167664670656,0.9869014386944385,0.5070422535211268,0.01309856130556152,0.9452921091072957,0.39827940648466603,904,9,880,15,5,4,0.9778761061946902,0.21052631578947367,0.4444444444444444,0.2857142857142857,0.9832402234636871,0.5555555555555556,0.01675977653631285,0.91495965238982,0.3824080976567331,3824,62,3716,46,31,31,0.9798640167364017,0.4025974025974026,0.5,0.4460431654676259,0.987772461456672,0.5,0.012227538543328018,0.9500908919414862,0.43006088211550036
+model_ET_pu_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,77.69140934944153,1.2948568224906922,4728,71,4571,86,34,37,0.9746192893401016,0.3008130081300813,0.5211267605633803,0.38144329896907214,0.9815331758642903,0.4788732394366197,0.018466824135709683,0.9428968053543507,0.37988079349086107,904,9,876,19,5,4,0.9734513274336283,0.17391304347826086,0.4444444444444444,0.25,0.9787709497206704,0.5555555555555556,0.021229050279329607,0.9160769708255743,0.41276268011543327,3824,62,3695,67,29,33,0.9748953974895398,0.33,0.532258064516129,0.4074074074074074,0.9821903242955875,0.46774193548387094,0.017809675704412546,0.9466695820685633,0.3918992950735184
+model_ET_pu_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,120.88866925239563,2.0148111542065936,4728,71,4571,86,35,36,0.9744077834179357,0.29508196721311475,0.5070422535211268,0.37305699481865284,0.9815331758642903,0.49295774647887325,0.018466824135709683,0.9432688032856793,0.35632532830639385,904,9,879,16,5,4,0.9767699115044248,0.2,0.4444444444444444,0.27586206896551724,0.982122905027933,0.5555555555555556,0.017877094972067038,0.9217877094972068,0.38450041503321486,3824,62,3692,70,30,32,0.9738493723849372,0.3137254901960784,0.5161290322580645,0.3902439024390244,0.9813928761297183,0.4838709677419355,0.018607123870281767,0.9466095590883368,0.36977013156762745
+model_ET_pu_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,106.17404961585999,1.7695674935976664,4728,71,4641,16,54,17,0.9851945854483926,0.5151515151515151,0.23943661971830985,0.3269230769230769,0.9965643117887052,0.7605633802816901,0.003435688211294825,0.9455612783421595,0.3715650874601461,904,9,892,3,5,4,0.9911504424778761,0.5714285714285714,0.4444444444444444,0.5,0.9966480446927374,0.5555555555555556,0.0033519553072625698,0.9353196772191186,0.42842752986492355,3824,62,3749,13,49,13,0.983786610878661,0.5,0.20967741935483872,0.29545454545454547,0.9965443912812334,0.7903225806451613,0.0034556087187666137,0.9474155819656669,0.36356733351960374
+model_ET_pu_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,82.65518403053284,1.3775864005088807,4728,71,4580,77,35,36,0.9763113367174281,0.3185840707964602,0.5070422535211268,0.391304347826087,0.9834657504831437,0.49295774647887325,0.016534249516856347,0.9428544641263946,0.35436137678040497,904,9,880,15,5,4,0.9778761061946902,0.21052631578947367,0.4444444444444444,0.2857142857142857,0.9832402234636871,0.5555555555555556,0.01675977653631285,0.924643078833023,0.38470043564313927,3824,62,3700,62,30,32,0.9759414225941423,0.3404255319148936,0.5161290322580645,0.41025641025641024,0.9835194045720361,0.4838709677419355,0.01648059542796385,0.9460307660647219,0.3687535529399977
+model_ET_pu_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_pu_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,123.70275974273682,2.061712662378947,4728,71,4635,22,47,24,0.9854060913705583,0.5217391304347826,0.3380281690140845,0.41025641025641024,0.9952759287094696,0.6619718309859155,0.004724071290530384,0.9487005779577616,0.4259564813417571,904,9,890,5,5,4,0.9889380530973452,0.4444444444444444,0.4444444444444444,0.4444444444444444,0.994413407821229,0.5555555555555556,0.00558659217877095,0.9303538175046555,0.5056068757279014,3824,62,3745,17,42,20,0.984571129707113,0.5405405405405406,0.3225806451612903,0.40404040404040403,0.9954811270600744,0.6774193548387096,0.004518872939925572,0.9517801100992952,0.4147358376878987
+model_ET_supervised_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,63.84041881561279,1.0640069802602132,4728,71,4657,0,66,5,0.9860406091370558,1.0,0.07042253521126761,0.13157894736842105,1.0,0.9295774647887324,0.0,0.9553995650951015,0.44559891436675103,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9279329608938547,0.5109520240817257,3824,62,3762,0,59,3,0.984571129707113,1.0,0.04838709677419355,0.09230769230769231,1.0,0.9516129032258065,0.0,0.9591607929893159,0.43312121548020954
+model_ET_supervised_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,26.79050636291504,0.4465084393819173,4728,71,4657,0,65,6,0.9862521150592216,1.0,0.08450704225352113,0.15584415584415584,1.0,0.9154929577464789,0.0,0.9546011305107864,0.4622851850458132,904,9,895,0,6,3,0.9933628318584071,1.0,0.3333333333333333,0.5,1.0,0.6666666666666666,0.0,0.9201738050900061,0.516873261585494,3824,62,3762,0,59,3,0.984571129707113,1.0,0.04838709677419355,0.09230769230769231,1.0,0.9516129032258065,0.0,0.9592015228687555,0.4515174716019063
+model_ET_supervised_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,45.076682806015015,0.7512780467669169,4728,71,4657,0,69,2,0.9854060913705583,1.0,0.028169014084507043,0.0547945205479452,1.0,0.971830985915493,0.0,0.9525657271954682,0.4356412526112598,904,9,895,0,8,1,0.9911504424778761,1.0,0.1111111111111111,0.2,1.0,0.8888888888888888,0.0,0.9317815021725636,0.5251450492609465,3824,62,3762,0,61,1,0.9840481171548117,1.0,0.016129032258064516,0.031746031746031744,1.0,0.9838709677419355,0.0,0.9553836325907633,0.41843805776851867
+model_ET_supervised_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,18.306095123291016,0.3051015853881836,4728,71,4657,0,65,6,0.9862521150592216,1.0,0.08450704225352113,0.15584415584415584,1.0,0.9154929577464789,0.0,0.9572277988307772,0.4579961401580452,904,9,895,0,6,3,0.9933628318584071,1.0,0.3333333333333333,0.5,1.0,0.6666666666666666,0.0,0.9270018621973929,0.5219244087813817,3824,62,3762,0,59,3,0.984571129707113,1.0,0.04838709677419355,0.09230769230769231,1.0,0.9516129032258065,0.0,0.96116298811545,0.44718476427977677
+model_ET_supervised_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,33.15771460533142,0.5526285767555237,4728,71,4654,3,58,13,0.987098138747885,0.8125,0.18309859154929578,0.2988505747126437,0.9993558084603822,0.8169014084507042,0.0006441915396177797,0.953108602225334,0.4648988205928246,904,9,893,2,6,3,0.9911504424778761,0.6,0.3333333333333333,0.42857142857142855,0.9977653631284916,0.6666666666666666,0.0022346368715083797,0.9025450031036624,0.4252996463057907,3824,62,3761,1,52,10,0.9861401673640168,0.9090909090909091,0.16129032258064516,0.273972602739726,0.9997341839447103,0.8387096774193549,0.0002658160552897395,0.9596645572876473,0.4868861186802772
+model_ET_supervised_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_ET_supervised_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,37.03258180618286,0.6172096967697144,4728,71,4657,0,65,6,0.9862521150592216,1.0,0.08450704225352113,0.15584415584415584,1.0,0.9154929577464789,0.0,0.9543697659437406,0.45731081328192,904,9,895,0,6,3,0.9933628318584071,1.0,0.3333333333333333,0.5,1.0,0.6666666666666666,0.0,0.9200496585971446,0.5170537927389657,3824,62,3762,0,59,3,0.984571129707113,1.0,0.04838709677419355,0.09230769230769231,1.0,0.9516129032258065,0.0,0.958867109121778,0.446047263192599
+model_RF_pu_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,42.984647035598755,0.7164107839266459,4728,71,4595,62,38,33,0.9788494077834179,0.3473684210526316,0.4647887323943662,0.39759036144578314,0.9866867081812326,0.5352112676056338,0.013313291818767448,0.944502747643257,0.41314388689946535,904,9,884,11,5,4,0.9823008849557522,0.26666666666666666,0.4444444444444444,0.3333333333333333,0.9877094972067039,0.5555555555555556,0.012290502793296089,0.9138423339540658,0.4470001697242661,3824,62,3711,51,33,29,0.9780334728033473,0.3625,0.46774193548387094,0.4084507042253521,0.9864433811802232,0.532258064516129,0.013556618819776715,0.9487832484436899,0.4191021823945725
+model_RF_pu_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,29.3424015045166,0.4890400250752767,4728,71,4596,61,38,33,0.9790609137055838,0.35106382978723405,0.4647887323943662,0.4,0.9869014386944385,0.5352112676056338,0.01309856130556152,0.9444422601747483,0.4089677391813839,904,9,885,10,5,4,0.9834070796460177,0.2857142857142857,0.4444444444444444,0.34782608695652173,0.9888268156424581,0.5555555555555556,0.0111731843575419,0.9144630664183737,0.44677775412233117,3824,62,3711,51,33,29,0.9780334728033473,0.3625,0.46774193548387094,0.4084507042253521,0.9864433811802232,0.532258064516129,0.013556618819776715,0.9485517312342439,0.4153182068657609
+model_RF_pu_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,52.97184228897095,0.8828640381495158,4728,71,4631,26,50,21,0.9839255499153976,0.44680851063829785,0.29577464788732394,0.3559322033898305,0.9944170066566459,0.704225352112676,0.0055829933433540905,0.9439765066672312,0.36971768238282215,904,9,891,4,5,4,0.9900442477876106,0.5,0.4444444444444444,0.47058823529411764,0.9955307262569832,0.5555555555555556,0.004469273743016759,0.933457479826195,0.43976839784190314,3824,62,3740,22,45,17,0.9824790794979079,0.4358974358974359,0.27419354838709675,0.33663366336633666,0.9941520467836257,0.7258064516129032,0.005847953216374269,0.9456148925588654,0.3590319158994692
+model_RF_pu_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,56.54481363296509,0.9424135605494182,4728,71,4632,25,49,22,0.9843485617597293,0.46808510638297873,0.30985915492957744,0.3728813559322034,0.9946317371698519,0.6901408450704225,0.005368262830148164,0.9436710449512622,0.3725512281474701,904,9,891,4,5,4,0.9900442477876106,0.5,0.4444444444444444,0.47058823529411764,0.9955307262569832,0.5555555555555556,0.004469273743016759,0.9330850403476102,0.42972094634184643,3824,62,3741,21,44,18,0.9830020920502092,0.46153846153846156,0.2903225806451613,0.3564356435643564,0.9944178628389154,0.7096774193548387,0.005582137161084529,0.9456234672703263,0.36556161220560734
+model_RF_pu_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,28.662107467651367,0.4777017911275228,4728,71,4591,66,37,34,0.9782148900169205,0.34,0.4788732394366197,0.39766081871345027,0.9858277861284088,0.5211267605633803,0.014172213871591153,0.9458485938175759,0.3909344311525199,904,9,885,10,5,4,0.9834070796460177,0.2857142857142857,0.4444444444444444,0.34782608695652173,0.9888268156424581,0.5555555555555556,0.0111731843575419,0.9251396648044693,0.45292861132542767,3824,62,3706,56,32,30,0.9769874476987448,0.3488372093023256,0.4838709677419355,0.40540540540540543,0.9851143009037746,0.5161290322580645,0.014885699096225412,0.9487918231551509,0.3868216640580115
+model_RF_pu_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_pu_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,41.19235801696777,0.6865393002827962,4728,71,4636,21,53,18,0.9843485617597293,0.46153846153846156,0.2535211267605634,0.32727272727272727,0.9954906592226755,0.7464788732394366,0.004509340777324458,0.9420197370609744,0.3505845016170188,904,9,892,3,5,4,0.9911504424778761,0.5714285714285714,0.4444444444444444,0.5,0.9966480446927374,0.5555555555555556,0.0033519553072625698,0.9354438237119801,0.4183311734629107,3824,62,3744,18,48,14,0.9827405857740585,0.4375,0.22580645161290322,0.2978723404255319,0.9952153110047847,0.7741935483870968,0.004784688995215311,0.9429910308518118,0.33967107904845484
+model_RF_supervised_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,13.129471063613892,0.2188245177268982,4728,71,4656,1,67,4,0.9856175972927242,0.8,0.056338028169014086,0.10526315789473684,0.999785269486794,0.9436619718309859,0.00021473051320592657,0.9040396555843544,0.3099394130002518,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9389199255121042,0.45773587880573713,3824,62,3761,1,60,2,0.9840481171548117,0.6666666666666666,0.03225806451612903,0.06153846153846154,0.9997341839447103,0.967741935483871,0.0002658160552897395,0.9033887259693711,0.28449460411540883
+model_RF_supervised_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,13.361087560653687,0.22268479267756144,4728,71,4656,1,68,3,0.9854060913705583,0.75,0.04225352112676056,0.08,0.999785269486794,0.9577464788732394,0.00021473051320592657,0.9388335596572781,0.42883871512801697,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.8685288640595903,0.42362481833477084,3824,62,3761,1,61,1,0.983786610878661,0.5,0.016129032258064516,0.03125,0.9997341839447103,0.9838709677419355,0.0002658160552897395,0.9462558522405721,0.47207855674456456
+model_RF_supervised_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,9.392892360687256,0.15654820601145428,4728,71,4656,1,68,3,0.9854060913705583,0.75,0.04225352112676056,0.08,0.999785269486794,0.9577464788732394,0.00021473051320592657,0.9094003574809388,0.34860273594436314,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9057107386716324,0.5125317061876677,3824,62,3761,1,61,1,0.983786610878661,0.5,0.016129032258064516,0.03125,0.9997341839447103,0.9838709677419355,0.0002658160552897395,0.91186911560426,0.3174744471105539
+model_RF_supervised_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,8.055122375488281,0.13425203959147136,4728,71,4657,0,68,3,0.9856175972927242,1.0,0.04225352112676056,0.08108108108108109,1.0,0.9577464788732394,0.0,0.9123551703175894,0.33441108769844863,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9345127250155183,0.48490971565684204,3824,62,3762,0,61,1,0.9840481171548117,1.0,0.016129032258064516,0.031746031746031744,1.0,0.9838709677419355,0.0,0.9108015640273703,0.30325839249215525
+model_RF_supervised_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,9.112311601638794,0.15187186002731323,4728,71,4655,2,68,3,0.9851945854483926,0.6,0.04225352112676056,0.07894736842105263,0.9995705389735882,0.9577464788732394,0.00042946102641185313,0.9355642119843821,0.43779528201008766,904,9,894,1,7,2,0.9911504424778761,0.6666666666666666,0.2222222222222222,0.3333333333333333,0.9988826815642458,0.7777777777777778,0.0011173184357541898,0.8546865301055245,0.4123708848159698,3824,62,3761,1,61,1,0.983786610878661,0.5,0.016129032258064516,0.03125,0.9997341839447103,0.9838709677419355,0.0002658160552897395,0.9448946167961448,0.4836024823405589
+model_RF_supervised_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_RF_supervised_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,17.61688995361328,0.29361483256022136,4728,71,4656,1,68,3,0.9854060913705583,0.75,0.04225352112676056,0.08,0.999785269486794,0.9577464788732394,0.00021473051320592657,0.897792812274117,0.31668159947087104,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9248913718187461,0.45728721163207403,3824,62,3761,1,61,1,0.983786610878661,0.5,0.016129032258064516,0.03125,0.9997341839447103,0.9838709677419355,0.0002658160552897395,0.8991163759839482,0.2900293205193154
+model_XGB_pu_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,4.651256084442139,0.0775209347407023,4728,71,4587,70,34,37,0.9780033840947546,0.34579439252336447,0.5211267605633803,0.4157303370786517,0.9849688640755851,0.4788732394366197,0.01503113592441486,0.9288183470589481,0.37253149430834054,904,9,888,7,4,5,0.9878318584070797,0.4166666666666667,0.5555555555555556,0.47619047619047616,0.9921787709497206,0.4444444444444444,0.00782122905027933,0.9565487274984481,0.5443184781420076,3824,62,3699,63,30,32,0.9756799163179917,0.3368421052631579,0.5161290322580645,0.40764331210191085,0.9832535885167464,0.4838709677419355,0.01674641148325359,0.9261331481195658,0.3538834608749478
+model_XGB_pu_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,3.669872999191284,0.061164549986521405,4728,71,4576,81,29,42,0.9767343485617598,0.34146341463414637,0.5915492957746479,0.4329896907216495,0.98260682843032,0.4084507042253521,0.017393171569680052,0.9310382371532178,0.44220584603783913,904,9,883,12,4,5,0.9823008849557522,0.29411764705882354,0.5555555555555556,0.38461538461538464,0.9865921787709497,0.4444444444444444,0.013407821229050279,0.9348230912476723,0.5182603645516074,3824,62,3693,69,25,37,0.975418410041841,0.3490566037735849,0.5967741935483871,0.44047619047619047,0.981658692185008,0.4032258064516129,0.018341307814992026,0.9303819176484709,0.4251840272211057
+model_XGB_pu_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,3.8302955627441406,0.063838259379069,4728,71,4586,71,34,37,0.9777918781725888,0.3425925925925926,0.5211267605633803,0.4134078212290503,0.9847541335623792,0.4788732394366197,0.015245866437620785,0.9348640695363937,0.4245710492021031,904,9,885,10,4,5,0.9845132743362832,0.3333333333333333,0.5555555555555556,0.4166666666666667,0.9888268156424581,0.4444444444444444,0.0111731843575419,0.945747982619491,0.49644777720049926,3824,62,3701,61,30,32,0.9762029288702929,0.34408602150537637,0.5161290322580645,0.4129032258064516,0.9837852206273259,0.4838709677419355,0.01621477937267411,0.9335974344463309,0.4145513820351087
+model_XGB_pu_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,9.871084928512573,0.16451808214187622,4728,71,4616,41,39,32,0.9830795262267343,0.4383561643835616,0.4507042253521127,0.4444444444444444,0.9911960489585571,0.5492957746478874,0.008803951041442989,0.932553448239361,0.37901311493458495,904,9,888,7,5,4,0.9867256637168141,0.36363636363636365,0.4444444444444444,0.4,0.9921787709497206,0.5555555555555556,0.00782122905027933,0.930477963997517,0.4319554057567376,3824,62,3728,34,34,28,0.9822175732217573,0.45161290322580644,0.45161290322580644,0.45161290322580644,0.9909622541201488,0.5483870967741935,0.009037745879851143,0.932937181663837,0.37055748704402675
+model_XGB_pu_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,4.087388038635254,0.06812313397725424,4728,71,4576,81,31,40,0.9763113367174281,0.3305785123966942,0.5633802816901409,0.4166666666666667,0.98260682843032,0.43661971830985913,0.017393171569680052,0.9332913953551674,0.3907542031182485,904,9,886,9,4,5,0.9856194690265486,0.35714285714285715,0.5555555555555556,0.43478260869565216,0.9899441340782122,0.4444444444444444,0.01005586592178771,0.9437616387337058,0.5918783382934327,3824,62,3690,72,27,35,0.9741108786610879,0.32710280373831774,0.5645161290322581,0.41420118343195267,0.9808612440191388,0.43548387096774194,0.019138755980861243,0.9319596645572876,0.3688010414478227
+model_XGB_pu_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_pu_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,7.8919336795806885,0.13153222799301148,4728,71,4588,69,34,37,0.9782148900169205,0.3490566037735849,0.5211267605633803,0.4180790960451977,0.985183594588791,0.4788732394366197,0.014816405411208933,0.9344013404023022,0.41140616698019167,904,9,886,9,4,5,0.9856194690265486,0.35714285714285715,0.5555555555555556,0.43478260869565216,0.9899441340782122,0.4444444444444444,0.01005586592178771,0.9502172563625078,0.5298304430027967,3824,62,3702,60,30,32,0.9764644351464435,0.34782608695652173,0.5161290322580645,0.4155844155844156,0.9840510366826156,0.4838709677419355,0.01594896331738437,0.9332201471420487,0.3948293467173613
+model_XGB_supervised_normal_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_normal_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,5.092371225357056,0.08487285375595092,4728,71,4653,4,55,16,0.9875211505922166,0.8,0.22535211267605634,0.3516483516483517,0.9991410779471763,0.7746478873239436,0.0008589220528237063,0.9292432715252218,0.46633194184550697,904,9,893,2,6,3,0.9911504424778761,0.6,0.3333333333333333,0.42857142857142855,0.9977653631284916,0.6666666666666666,0.0022346368715083797,0.9484792054624457,0.46459973178105496,3824,62,3760,2,49,13,0.986663179916318,0.8666666666666667,0.20967741935483872,0.33766233766233766,0.9994683678894205,0.7903225806451613,0.000531632110579479,0.9270849410917322,0.4824182792587978
+model_XGB_supervised_normal_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_normal_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,3.9309542179107666,0.0655159036318461,4728,71,4655,2,63,8,0.9862521150592216,0.8,0.11267605633802817,0.19753086419753085,0.9995705389735882,0.8873239436619719,0.00042946102641185313,0.9275345005398508,0.44439749793785804,904,9,895,0,6,3,0.9933628318584071,1.0,0.3333333333333333,0.5,1.0,0.6666666666666666,0.0,0.9566728739913097,0.4886770131440351,3824,62,3760,2,57,5,0.984571129707113,0.7142857142857143,0.08064516129032258,0.14492753623188406,0.9994683678894205,0.9193548387096774,0.000531632110579479,0.9252070792817821,0.45146045643566773
+model_XGB_supervised_normal_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_normal_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,6.661342144012451,0.11102236906687418,4728,71,4654,3,56,15,0.9875211505922166,0.8333333333333334,0.2112676056338028,0.33707865168539325,0.9993558084603822,0.7887323943661971,0.0006441915396177797,0.927768889480322,0.43621452803897554,904,9,893,2,6,3,0.9911504424778761,0.6,0.3333333333333333,0.42857142857142855,0.9977653631284916,0.6666666666666666,0.0022346368715083797,0.939913097454997,0.4239432138100045,3824,62,3761,1,50,12,0.986663179916318,0.9230769230769231,0.1935483870967742,0.32,0.9997341839447103,0.8064516129032258,0.0002658160552897395,0.9282168030045789,0.46947082191995665
+model_XGB_supervised_weighted_F1_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_weighted_F1_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,1.3843553066253662,0.023072588443756103,4728,71,4646,11,58,13,0.9854060913705583,0.5416666666666666,0.18309859154929578,0.2736842105263158,0.9976379643547348,0.8169014084507042,0.002362035645265192,0.9126833148342492,0.3560702303037348,904,9,894,1,7,2,0.9911504424778761,0.6666666666666666,0.2222222222222222,0.3333333333333333,0.9988826815642458,0.7777777777777778,0.0011173184357541898,0.9776536312849162,0.47891203197466886,3824,62,3752,10,51,11,0.9840481171548117,0.5238095238095238,0.1774193548387097,0.26506024096385544,0.9973418394471026,0.8225806451612904,0.002658160552897395,0.9114961156557082,0.342459594653059
+model_XGB_supervised_weighted_FB_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_weighted_FB_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,2.361746072769165,0.03936243454615275,4728,71,4650,7,55,16,0.9868866328257191,0.6956521739130435,0.22535211267605634,0.3404255319148936,0.9984968864075585,0.7746478873239436,0.001503113592441486,0.929102638160939,0.4639064536999952,904,9,892,3,6,3,0.9900442477876106,0.5,0.3333333333333333,0.4,0.9966480446927374,0.6666666666666666,0.0033519553072625698,0.9422718808193669,0.4547986659037171,3824,62,3758,4,49,13,0.9861401673640168,0.7647058823529411,0.20967741935483872,0.3291139240506329,0.998936735778841,0.7903225806451613,0.001063264221158958,0.9271020905146543,0.4775050650943073
+model_XGB_supervised_weighted_PR_AUC_64log_gc_tetra,/TomaszLab/tRNA/Modele_final/results_models/model_XGB_supervised_weighted_PR_AUC_64log_gc_tetra.joblib,/TomaszLab/tRNA/Modele_final/results_models/feature_columns_64log_gc_tetra.json,4744,4728,16,1.4389727115631104,0.02398287852605184,4728,71,4654,3,63,8,0.9860406091370558,0.7272727272727273,0.11267605633802817,0.1951219512195122,0.9993558084603822,0.8873239436619719,0.0006441915396177797,0.9258302661146176,0.4537539075820669,904,9,895,0,7,2,0.9922566371681416,1.0,0.2222222222222222,0.36363636363636365,1.0,0.7777777777777778,0.0,0.9633147113594042,0.5472066604419547,3824,62,3759,3,56,6,0.984571129707113,0.6666666666666666,0.0967741935483871,0.16901408450704225,0.9992025518341308,0.9032258064516129,0.0007974481658692185,0.9215735453002006,0.43755002037403923

results_models/best_params_ET_pu_normal_F1_64log_gc_tetra.json

@@ -0,0 +1,8 @@
+{
+  "n_estimators": 833,
+  "max_depth": 13,
+  "min_samples_split": 6,
+  "min_samples_leaf": 2,
+  "max_features": "sqrt",
+  "class_weight": "balanced"
+}

results_models/best_params_ET_pu_normal_FB_64log_gc_tetra.json

@@ -0,0 +1,8 @@
+{
+  "n_estimators": 950,
+  "max_depth": 18,
+  "min_samples_split": 9,
+  "min_samples_leaf": 6,
+  "max_features": "sqrt",
+  "class_weight": "balanced"
+}