| |
| import argparse |
| import json |
| from collections import Counter, defaultdict |
| from itertools import combinations |
| from pathlib import Path |
| from typing import Dict, Iterable, List |
|
|
| import numpy as np |
| import pandas as pd |
|
|
|
|
| DNA = set("ACGT") |
|
|
|
|
| def read_jsonl(path: Path) -> List[dict]: |
| rows = [] |
| with open(path, "r", encoding="utf-8") as f: |
| for line in f: |
| line = line.strip() |
| if line: |
| rows.append(json.loads(line)) |
| return rows |
|
|
|
|
| def get_sequence(row: dict) -> str: |
| for key in ["generated_sequence", "sequence", "reference_sequence"]: |
| value = row.get(key) |
| if isinstance(value, str) and value: |
| return value.upper() |
| return "" |
|
|
|
|
| def load_generated(path: Path, method: str) -> pd.DataFrame: |
| rows = read_jsonl(path) |
| out = [] |
| for row in rows: |
| seq = get_sequence(row) |
| if not seq: |
| continue |
| out.append( |
| { |
| "method": method, |
| "source": row.get("source", "generated"), |
| "activity_bucket": row.get("activity_bucket"), |
| "condition_token": row.get("condition_token"), |
| "sequence": seq, |
| "prediction_sum": row.get("generated_prediction_sum", row.get("prediction_sum")), |
| "prediction_label_0": ( |
| row.get("generated_prediction", [None, None])[0] |
| if isinstance(row.get("generated_prediction"), list) |
| else row.get("prediction_label_0") |
| ), |
| "prediction_label_1": ( |
| row.get("generated_prediction", [None, None])[1] |
| if isinstance(row.get("generated_prediction"), list) and len(row.get("generated_prediction")) > 1 |
| else row.get("prediction_label_1") |
| ), |
| "diffusion_pll": row.get("diffusion_pll"), |
| } |
| ) |
| return pd.DataFrame(out) |
|
|
|
|
| def load_reference(dataset_dir: Path, split: str = "valid", limit: int = 20000) -> pd.DataFrame: |
| path = dataset_dir / f"{split}.parquet" |
| df = pd.read_parquet(path) |
| if limit and len(df) > limit: |
| df = df.sample(n=limit, random_state=42) |
| return pd.DataFrame( |
| { |
| "method": "reference", |
| "source": "reference", |
| "activity_bucket": None, |
| "condition_token": None, |
| "sequence": df["sequence"].astype(str).str.upper(), |
| "prediction_sum": np.nan, |
| "prediction_label_0": np.nan, |
| "prediction_label_1": np.nan, |
| "diffusion_pll": np.nan, |
| } |
| ) |
|
|
|
|
| def gc_content(seq: str) -> float: |
| bases = [c for c in seq if c in DNA] |
| if not bases: |
| return np.nan |
| return sum(c in "GC" for c in bases) / len(bases) |
|
|
|
|
| def valid_dna(seq: str) -> bool: |
| return bool(seq) and set(seq).issubset(DNA) |
|
|
|
|
| def max_homopolymer(seq: str) -> int: |
| best = cur = 0 |
| last = None |
| for char in seq: |
| if char == last: |
| cur += 1 |
| else: |
| last = char |
| cur = 1 |
| best = max(best, cur) |
| return best |
|
|
|
|
| def kmers(seq: str, k: int) -> Iterable[str]: |
| for i in range(0, max(0, len(seq) - k + 1)): |
| mer = seq[i : i + k] |
| if set(mer).issubset(DNA): |
| yield mer |
|
|
|
|
| def kmer_distribution(seqs: Iterable[str], k: int) -> Dict[str, float]: |
| counts = Counter() |
| total = 0 |
| for seq in seqs: |
| for mer in kmers(seq, k): |
| counts[mer] += 1 |
| total += 1 |
| if total == 0: |
| return {} |
| return {key: value / total for key, value in counts.items()} |
|
|
|
|
| def js_divergence(p: Dict[str, float], q: Dict[str, float]) -> float: |
| keys = sorted(set(p) | set(q)) |
| pv = np.asarray([p.get(key, 0.0) for key in keys], dtype=float) |
| qv = np.asarray([q.get(key, 0.0) for key in keys], dtype=float) |
| m = 0.5 * (pv + qv) |
|
|
| def kl(a, b): |
| mask = a > 0 |
| return float(np.sum(a[mask] * np.log2(a[mask] / b[mask]))) |
|
|
| return 0.5 * kl(pv, m) + 0.5 * kl(qv, m) |
|
|
|
|
| def hamming_distance(a: str, b: str) -> int: |
| n = min(len(a), len(b)) |
| return sum(x != y for x, y in zip(a[:n], b[:n])) + abs(len(a) - len(b)) |
|
|
|
|
| def mean_pairwise_distance(seqs: List[str], max_pairs: int = 20000) -> float: |
| if len(seqs) < 2: |
| return np.nan |
| pairs = list(combinations(range(len(seqs)), 2)) |
| if len(pairs) > max_pairs: |
| rng = np.random.default_rng(42) |
| pairs = [pairs[i] for i in rng.choice(len(pairs), size=max_pairs, replace=False)] |
| return float(np.mean([hamming_distance(seqs[i], seqs[j]) for i, j in pairs])) |
|
|
|
|
| def nearest_reference_distance(seqs: List[str], refs: List[str], max_refs: int = 5000) -> List[float]: |
| if not refs: |
| return [np.nan] * len(seqs) |
| if len(refs) > max_refs: |
| rng = np.random.default_rng(42) |
| refs = [refs[i] for i in rng.choice(len(refs), size=max_refs, replace=False)] |
| out = [] |
| for seq in seqs: |
| out.append(float(min(hamming_distance(seq, ref) for ref in refs))) |
| return out |
|
|
|
|
| def summarize(df: pd.DataFrame, reference_df: pd.DataFrame, k_values: List[int]) -> dict: |
| reference_kmers = { |
| k: kmer_distribution(reference_df["sequence"].tolist(), k) |
| for k in k_values |
| } |
| reference_sequences = reference_df["sequence"].tolist() |
| summary = {"methods": {}} |
| annotated_frames = [] |
|
|
| for method, group in df.groupby("method"): |
| group = group.copy() |
| seqs = group["sequence"].tolist() |
| group["length"] = group["sequence"].str.len() |
| group["valid_dna"] = group["sequence"].map(valid_dna) |
| group["gc_content"] = group["sequence"].map(gc_content) |
| group["max_homopolymer"] = group["sequence"].map(max_homopolymer) |
| group["nearest_reference_hamming"] = nearest_reference_distance(seqs, reference_sequences) |
| annotated_frames.append(group) |
|
|
| method_summary = { |
| "num_sequences": int(len(group)), |
| "valid_dna_rate": float(group["valid_dna"].mean()), |
| "unique_rate": float(group["sequence"].nunique() / len(group)), |
| "mean_length": float(group["length"].mean()), |
| "mean_gc_content": float(group["gc_content"].mean()), |
| "mean_max_homopolymer": float(group["max_homopolymer"].mean()), |
| "mean_pairwise_hamming": mean_pairwise_distance(seqs), |
| "mean_nearest_reference_hamming": float(group["nearest_reference_hamming"].mean()), |
| } |
| for k in k_values: |
| method_summary[f"kmer{k}_js_to_reference"] = js_divergence( |
| kmer_distribution(seqs, k), reference_kmers[k] |
| ) |
| for col in ["prediction_sum", "prediction_label_0", "prediction_label_1", "diffusion_pll"]: |
| if col in group and group[col].notna().any(): |
| method_summary[f"mean_{col}"] = float(pd.to_numeric(group[col], errors="coerce").mean()) |
| summary["methods"][method] = method_summary |
|
|
| annotated = pd.concat(annotated_frames, ignore_index=True) if annotated_frames else pd.DataFrame() |
| return summary, annotated |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Compute paper-level sequence quality metrics.") |
| parser.add_argument("--dataset_dir", required=True) |
| parser.add_argument("--reference_split", default="valid") |
| parser.add_argument("--input", action="append", default=[], help="method=path/to/jsonl. Repeatable.") |
| parser.add_argument("--output_dir", required=True) |
| parser.add_argument("--k_values", default="3,4") |
| args = parser.parse_args() |
|
|
| frames = [] |
| for item in args.input: |
| method, path = item.split("=", 1) |
| frames.append(load_generated(Path(path), method)) |
| reference_df = load_reference(Path(args.dataset_dir), split=args.reference_split) |
| frames.append(reference_df) |
| all_df = pd.concat(frames, ignore_index=True) |
|
|
| k_values = [int(k) for k in args.k_values.split(",") if k.strip()] |
| summary, annotated = summarize(all_df, reference_df, k_values) |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| annotated.to_csv(output_dir / "sequence_metrics_rows.csv", index=False) |
| (output_dir / "sequence_metrics_summary.json").write_text( |
| json.dumps(summary, indent=2), encoding="utf-8" |
| ) |
| print(output_dir / "sequence_metrics_summary.json") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
|
|
