File size: 4,882 Bytes
c289d87 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | from __future__ import annotations
from typing import Dict
import numpy as np
import pandas as pd
def backend_score_semantics(backend_name: str) -> str:
name = str(backend_name).strip().lower()
if name == "rdock":
return "rdock_docking_score_lower_better"
if name == "haddock":
return "haddock_emscoring_energy_proxy_lower_better"
return "unknown_score_semantics"
def build_backend_comparison_table(df: pd.DataFrame) -> pd.DataFrame:
"""Build backend-comparison rows with explicit semantics and normalized scores."""
if df.empty:
return pd.DataFrame(
columns=[
"ligand_id",
"backend_name",
"backend_mode",
"raw_score",
"normalized_score",
"zscore_within_backend",
"score_semantics",
"direct_comparison_justified",
"provenance_path",
"parsed_from",
]
)
work = df.copy()
if "docking_score" in work.columns and "raw_score" not in work.columns:
work["raw_score"] = pd.to_numeric(work["docking_score"], errors="coerce")
work["backend_name"] = work["backend_name"].astype(str)
work["backend_mode"] = work.get("backend_mode", "").astype(str)
work["score_semantics"] = work["backend_name"].map(backend_score_semantics)
work["provenance_path"] = work.get("raw_output_file", "").astype(str)
work["parsed_from"] = work.get("parsed_from", "").astype(str)
norm = np.full(work.shape[0], np.nan, dtype=float)
z = np.full(work.shape[0], np.nan, dtype=float)
for backend, idx in work.groupby("backend_name").groups.items():
vals = pd.to_numeric(work.loc[idx, "raw_score"], errors="coerce").to_numpy(dtype=float)
valid = np.isfinite(vals)
if valid.any():
v = vals[valid]
ranks = pd.Series(v).rank(method="average", pct=True).to_numpy(dtype=float)
# lower score is better -> invert percentile for "higher is better normalized"
nv = 1.0 - ranks
mu = float(np.mean(v))
sd = float(np.std(v))
zv = (v - mu) / (sd if sd > 1e-9 else 1.0)
# map back
norm_vals = np.full(vals.shape[0], np.nan, dtype=float)
z_vals = np.full(vals.shape[0], np.nan, dtype=float)
norm_vals[valid] = nv
z_vals[valid] = zv
norm[list(idx)] = norm_vals
z[list(idx)] = z_vals
work["normalized_score"] = norm
work["zscore_within_backend"] = z
unique_sem = set(work["score_semantics"].astype(str).tolist())
direct = len(unique_sem) == 1
work["direct_comparison_justified"] = bool(direct)
if not direct:
work["direct_comparison_justified"] = False
cols = [
"ligand_id",
"backend_name",
"backend_mode",
"raw_score",
"normalized_score",
"zscore_within_backend",
"score_semantics",
"direct_comparison_justified",
"provenance_path",
"parsed_from",
]
for c in cols:
if c not in work.columns:
work[c] = np.nan
return work[cols].copy()
def summarize_backend_table(df: pd.DataFrame) -> pd.DataFrame:
if df.empty:
return pd.DataFrame(
columns=[
"backend_name",
"score_semantics",
"n_scores",
"mean_raw_score",
"std_raw_score",
"mean_normalized_score",
"direct_comparison_justified",
]
)
rows = []
for backend, sub in df.groupby("backend_name"):
rows.append(
{
"backend_name": str(backend),
"score_semantics": str(sub["score_semantics"].iloc[0]),
"n_scores": int(sub.shape[0]),
"mean_raw_score": float(pd.to_numeric(sub["raw_score"], errors="coerce").mean()),
"std_raw_score": float(pd.to_numeric(sub["raw_score"], errors="coerce").std()),
"mean_normalized_score": float(pd.to_numeric(sub["normalized_score"], errors="coerce").mean()),
"direct_comparison_justified": bool(sub["direct_comparison_justified"].all()),
}
)
return pd.DataFrame(rows)
def semantic_compatibility_notes() -> Dict[str, str]:
return {
"rdock": "Pose generation + docking score; lower score is better.",
"haddock": (
"HADDOCK emscoring on provided complexes/poses; energy proxy; "
"lower score is better; in this repository treated as rescoring semantics."
),
"cross_backend": (
"Direct raw-score comparison between rDock and HADDOCK is approximate; "
"prefer within-backend normalization / rank statistics."
),
}
|