File size: 8,388 Bytes
0161e74 | 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 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | """DE metrics module."""
from typing import Literal
import polars as pl
from sklearn.metrics import auc, average_precision_score, roc_curve
from .._types import DEComparison, DESortBy
def de_overlap_metric(
data: DEComparison,
k: int | None,
metric: Literal["precision", "overlap"] = "overlap",
fdr_threshold: float = 0.05,
sort_by: DESortBy = DESortBy.ABS_FOLD_CHANGE,
) -> dict[str, float]:
"""Compute overlap between real and predicted DE genes.
Note: use `k` argument for measuring recall and use `topk` argument for measuring precision.
"""
return data.compute_overlap(
k=k,
metric=metric,
fdr_threshold=fdr_threshold,
sort_by=sort_by,
)
class DESpearmanSignificant:
"""Compute Spearman correlation on number of significant DE genes."""
def __init__(self, fdr_threshold: float = 0.05) -> None:
self.fdr_threshold = fdr_threshold
def __call__(self, data: DEComparison) -> float:
"""Compute correlation between number of significant genes in real and predicted DE."""
filt_real = (
data.real.filter_to_significant(fdr_threshold=self.fdr_threshold)
.group_by(data.real.target_col)
.len()
)
filt_pred = (
data.pred.filter_to_significant(fdr_threshold=self.fdr_threshold)
.group_by(data.pred.target_col)
.len()
)
merged = filt_real.join(
filt_pred,
left_on=data.real.target_col,
right_on=data.pred.target_col,
suffix="_pred",
how="left",
coalesce=True,
).fill_null(0)
# No significant genes in either real or predicted DE. Set to 1.0 since perfect
# agreement but will fail spearman test
if merged.shape[0] == 0:
return 1.0
return float(
merged.select(
pl.corr(
pl.col("len"),
pl.col("len_pred"),
method="spearman",
).alias("spearman_corr_nsig")
)
.to_numpy()
.flatten()[0]
)
class DEDirectionMatch:
"""Compute agreement in direction of DE gene changes."""
def __init__(self, fdr_threshold: float = 0.05) -> None:
self.fdr_threshold = fdr_threshold
def __call__(self, data: DEComparison) -> dict[str, float]:
"""Compute directional agreement between real and predicted DE genes."""
matches = {}
merged = data.real.filter_to_significant(fdr_threshold=self.fdr_threshold).join(
data.pred.data,
on=[data.real.target_col, data.real.feature_col],
suffix="_pred",
how="inner",
)
for row in (
merged.with_columns(
direction_match=pl.col(data.real.log2_fold_change_col).sign()
== pl.col(f"{data.real.log2_fold_change_col}_pred").sign()
)
.group_by(
data.real.target_col,
)
.agg(pl.mean("direction_match"))
.iter_rows()
):
matches.update({row[0]: row[1]})
return matches
class DESpearmanLFC:
"""Compute Spearman correlation on log fold changes of significant genes."""
def __init__(self, fdr_threshold: float = 0.05) -> None:
self.fdr_threshold = fdr_threshold
def __call__(self, data: DEComparison) -> dict[str, float]:
"""Compute correlation between log fold changes of significant genes."""
correlations = {}
merged = data.real.filter_to_significant(fdr_threshold=self.fdr_threshold).join(
data.pred.data,
on=[data.real.target_col, data.real.feature_col],
suffix="_pred",
how="inner",
)
for row in (
merged.group_by(
data.real.target_col,
)
.agg(
pl.corr(
pl.col(data.real.fold_change_col).cast(pl.Float64),
pl.col(f"{data.real.fold_change_col}_pred").cast(pl.Float64),
method="spearman",
).alias("spearman_corr"),
)
.iter_rows()
):
correlations.update({row[0]: row[1]})
return correlations
class DESigGenesRecall:
"""Compute recall of significant genes."""
def __init__(self, fdr_threshold: float = 0.05) -> None:
self.fdr_threshold = fdr_threshold
def __call__(self, data: DEComparison) -> dict[str, float]:
"""Compute recall of significant genes between real and predicted DE."""
filt_real = data.real.filter_to_significant(fdr_threshold=self.fdr_threshold)
filt_pred = data.pred.filter_to_significant(fdr_threshold=self.fdr_threshold)
recall_frame = (
filt_real.join(
filt_pred,
on=[data.real.target_col, data.real.feature_col],
how="inner",
coalesce=True,
)
.group_by(data.real.target_col)
.len()
.join(
filt_real.group_by(data.real.target_col).len(),
on=data.real.target_col,
how="full",
suffix="_expected",
coalesce=True,
)
.fill_null(0)
.with_columns(recall=pl.col("len") / pl.col("len_expected"))
.select([data.real.target_col, "recall"])
)
return {row[0]: row[1] for row in recall_frame.iter_rows()}
class DENsigCounts:
"""Compute counts of significant genes."""
def __init__(self, fdr_threshold: float = 0.05) -> None:
self.fdr_threshold = fdr_threshold
def __call__(self, data: DEComparison) -> dict[str, dict[str, int]]:
"""Compute counts of significant genes in real and predicted DE."""
counts = {}
for pert in data.iter_perturbations():
real_sig = data.real.get_significant_genes(pert, self.fdr_threshold)
pred_sig = data.pred.get_significant_genes(pert, self.fdr_threshold)
counts[pert] = {
"real": int(real_sig.size),
"pred": int(pred_sig.size),
}
return counts
def compute_pr_auc(data: DEComparison) -> dict[str, float]:
"""Compute precision-recall AUC per perturbation for significant recovery."""
return compute_generic_auc(data, method="pr")
def compute_roc_auc(data: DEComparison) -> dict[str, float]:
"""Compute ROC AUC per perturbation for significant recovery."""
return compute_generic_auc(data, method="roc")
def compute_generic_auc(
data: DEComparison,
method: Literal["pr", "roc"] = "pr",
) -> dict[str, float]:
"""Compute AUC values for significant recovery per perturbation."""
target_col = data.real.target_col
feature_col = data.real.feature_col
real_fdr_col = data.real.fdr_col
pred_fdr_col = data.pred.fdr_col
labeled_real = data.real.data.with_columns(
(pl.col(real_fdr_col) < 0.05).cast(pl.Float32).alias("label")
).select([target_col, feature_col, "label"])
merged = (
data.pred.data.select([target_col, feature_col, pred_fdr_col])
.join(
labeled_real,
on=[target_col, feature_col],
how="inner",
coalesce=True,
)
.drop_nulls(["label"])
.with_columns((-pl.col(pred_fdr_col).replace(0, 1e-10).log10()).alias("nlp"))
.drop_nulls(["nlp"])
)
results: dict[str, float] = {}
for pert in data.iter_perturbations():
pert_data = merged.filter(pl.col(target_col) == pert)
if pert_data.shape[0] == 0:
results[pert] = float("nan")
continue
labels = pert_data["label"].to_numpy()
scores = pert_data["nlp"].to_numpy()
if not (0 < labels.sum() < len(labels)):
results[pert] = float("nan")
continue
match method:
case "pr":
results[pert] = float(average_precision_score(labels, scores))
case "roc":
fpr, tpr, _ = roc_curve(labels, scores)
results[pert] = float(auc(fpr, tpr))
case _:
raise ValueError(f"Invalid AUC method: {method}")
return results
|