import argparse import json import logging import math import random import shutil from pathlib import Path from typing import Any, Dict, List, Optional, Sequence, Tuple import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np import pandas as pd import torch from transformers import AutoModelForMaskedLM, AutoModelForSequenceClassification, AutoTokenizer logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) BUCKET_TOKENS = {"low": "", "mid": "", "high": ""} BUCKET_ORDER = ["low", "mid", "high"] DNA_BASES = ("A", "C", "G", "T") def parse_args(): parser = argparse.ArgumentParser( description="Sample a trained masked discrete diffusion model and score generated DeepSTARR sequences." ) parser.add_argument("--diffusion_model", type=str, required=True) parser.add_argument("--base_model_for_code", type=str, default=None, help="Optional base model dir to copy custom remote-code files from.") parser.add_argument("--dataset_dir", type=str, required=True) parser.add_argument("--predictor_model", type=str, default=None) parser.add_argument("--output_dir", type=str, default="results/deepstarr_discrete_diffusion_eval") parser.add_argument("--split", type=str, default="valid", choices=["train", "valid", "test"]) parser.add_argument("--sequence_col", type=str, default="sequence") parser.add_argument("--label_col", type=str, default="label") parser.add_argument("--score_mode", type=str, default="sum", choices=["sum", "mean", "label_0", "label_1", "max"]) parser.add_argument("--low_quantile", type=float, default=0.25) parser.add_argument("--high_quantile", type=float, default=0.75) parser.add_argument("--conditioned", action="store_true") parser.add_argument("--num_per_bucket", type=int, default=128) parser.add_argument("--sequence_length", type=int, default=246) parser.add_argument("--num_diffusion_steps", type=int, default=64) parser.add_argument("--batch_size", type=int, default=32) parser.add_argument("--predictor_batch_size", type=int, default=64) parser.add_argument("--score_batch_size", type=int, default=16) parser.add_argument("--pll_chunk_size", type=int, default=64) parser.add_argument("--max_length", type=int, default=256) parser.add_argument("--temperature", type=float, default=1.0) parser.add_argument("--top_k", type=int, default=0) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--bf16", action="store_true") parser.add_argument("--attn_implementation", type=str, default="sdpa", choices=["sdpa", "eager", "flash_attention_2"]) return parser.parse_args() def normalize_label(value: Any) -> List[float]: if hasattr(value, "tolist"): value = value.tolist() if isinstance(value, str): value = json.loads(value) return [float(value[0]), float(value[1])] def compute_activity_score(label: Sequence[float], mode: str) -> float: if mode == "sum": return float(label[0] + label[1]) if mode == "mean": return float((label[0] + label[1]) / 2.0) if mode == "label_0": return float(label[0]) if mode == "label_1": return float(label[1]) if mode == "max": return float(max(label[0], label[1])) raise ValueError(f"Unsupported score_mode: {mode}") def assign_bucket(score: float, low_threshold: float, high_threshold: float) -> str: if score <= low_threshold: return "low" if score >= high_threshold: return "high" return "mid" def load_bucketed_reference(args) -> pd.DataFrame: train_df = pd.read_parquet(Path(args.dataset_dir) / "train.parquet") split_df = pd.read_parquet(Path(args.dataset_dir) / f"{args.split}.parquet") train_scores = train_df[args.label_col].map( lambda value: compute_activity_score(normalize_label(value), args.score_mode) ) low_threshold = float(train_scores.quantile(args.low_quantile)) high_threshold = float(train_scores.quantile(args.high_quantile)) out = split_df.copy() out["activity_score"] = out[args.label_col].map( lambda value: compute_activity_score(normalize_label(value), args.score_mode) ) out["activity_bucket"] = out["activity_score"].map( lambda score: assign_bucket(score, low_threshold, high_threshold) ) out["condition_token"] = out["activity_bucket"].map(BUCKET_TOKENS) out[args.sequence_col] = out[args.sequence_col].astype(str).str.strip().str.upper() return out def resolve_dtype(args): if args.bf16 and torch.cuda.is_available() and torch.cuda.is_bf16_supported(): return torch.bfloat16 return torch.float32 def ensure_remote_code_files(model_dir: str, fallback_model_dir: Optional[str] = None): target = Path(model_dir) missing = [ filename for filename in ("configuration_generanno.py", "modeling_generanno.py", "tokenizer.py") if not (target / filename).exists() ] if not missing: return if fallback_model_dir is None: logger.warning( "Model directory %s is missing remote-code files: %s", model_dir, ", ".join(missing), ) return source = Path(fallback_model_dir) for filename in missing: src = source / filename if src.exists(): shutil.copy2(src, target / filename) logger.info("Copied %s from %s to %s", filename, source, target) def get_base_ids(tokenizer) -> Tuple[List[int], Dict[int, str]]: base_ids = [] id_to_base = {} for base in DNA_BASES: token_id = tokenizer.convert_tokens_to_ids(base) if token_id is None or token_id == tokenizer.unk_token_id: encoded = tokenizer(base, add_special_tokens=False)["input_ids"] if len(encoded) == 1: token_id = encoded[0] if token_id is None or token_id == tokenizer.unk_token_id: raise ValueError(f"Could not resolve tokenizer id for base {base!r}.") base_ids.append(int(token_id)) id_to_base[int(token_id)] = base return base_ids, id_to_base def encode_initial_batch( tokenizer, buckets: Sequence[str], sequence_length: int, conditioned: bool, ) -> torch.Tensor: mask_id = tokenizer.mask_token_id if mask_id is None: raise ValueError("Tokenizer must define a mask token for diffusion sampling.") rows = [] for bucket in buckets: prefix_ids: List[int] = [] if conditioned: prefix_ids = tokenizer(BUCKET_TOKENS[bucket], add_special_tokens=False)["input_ids"] body_ids = [mask_id] * sequence_length token_ids = tokenizer.build_inputs_with_special_tokens(prefix_ids + body_ids) rows.append(torch.tensor(token_ids, dtype=torch.long)) max_len = max(row.numel() for row in rows) pad_id = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id padded = torch.full((len(rows), max_len), int(pad_id), dtype=torch.long) for idx, row in enumerate(rows): padded[idx, : row.numel()] = row return padded def sample_from_logits(logits: torch.Tensor, base_ids: Sequence[int], temperature: float, top_k: int) -> torch.Tensor: restricted = logits[:, list(base_ids)] if temperature <= 0: return torch.tensor([base_ids[i] for i in restricted.argmax(dim=-1).tolist()], device=logits.device) restricted = restricted / temperature if top_k and 0 < top_k < restricted.size(-1): values, indices = torch.topk(restricted, k=top_k, dim=-1) probs = torch.softmax(values, dim=-1) sampled = torch.multinomial(probs, num_samples=1).squeeze(-1) return torch.tensor([base_ids[i] for i in indices[torch.arange(indices.size(0), device=indices.device), sampled].tolist()], device=logits.device) probs = torch.softmax(restricted, dim=-1) sampled = torch.multinomial(probs, num_samples=1).squeeze(-1) return torch.tensor([base_ids[i] for i in sampled.tolist()], device=logits.device) def iterative_unmask( model, tokenizer, buckets: Sequence[str], args, base_ids: Sequence[int], id_to_base: Dict[int, str], device: str, ) -> List[str]: input_ids = encode_initial_batch(tokenizer, buckets, args.sequence_length, args.conditioned).to(device) attention_mask = torch.ones_like(input_ids) mask_id = tokenizer.mask_token_id model.eval() with torch.inference_mode(): for step in range(args.num_diffusion_steps, 0, -1): masked = input_ids == mask_id if not masked.any(): break logits = model(input_ids=input_ids, attention_mask=attention_mask).logits for row_idx in range(input_ids.size(0)): positions = torch.nonzero(masked[row_idx], as_tuple=False).flatten() if positions.numel() == 0: continue fill_count = max(1, math.ceil(positions.numel() / step)) confidences = torch.softmax(logits[row_idx, positions][:, list(base_ids)], dim=-1).max(dim=-1).values selected = positions[torch.topk(confidences, k=min(fill_count, positions.numel())).indices] sampled = sample_from_logits( logits[row_idx, selected], base_ids=base_ids, temperature=args.temperature, top_k=args.top_k, ) input_ids[row_idx, selected] = sampled sequences = [] for row in input_ids.detach().cpu().tolist(): chars = [id_to_base[token_id] for token_id in row if token_id in id_to_base] sequences.append("".join(chars)[: args.sequence_length]) return sequences def load_diffusion_model(args, dtype): fallback = getattr(args, "base_model_for_code", None) ensure_remote_code_files(args.diffusion_model, fallback) tokenizer = AutoTokenizer.from_pretrained(args.diffusion_model, trust_remote_code=True) model = AutoModelForMaskedLM.from_pretrained( args.diffusion_model, trust_remote_code=True, torch_dtype=dtype, ) if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token or tokenizer.mask_token device = "cuda" if torch.cuda.is_available() else "cpu" model.to(device) return tokenizer, model, device def load_predictor(args, dtype): if not args.predictor_model: return None, None, None tokenizer = AutoTokenizer.from_pretrained(args.predictor_model, trust_remote_code=True) if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token or tokenizer.mask_token try: model = AutoModelForSequenceClassification.from_pretrained( args.predictor_model, trust_remote_code=True, attn_implementation=args.attn_implementation, torch_dtype=dtype, ) except TypeError: model = AutoModelForSequenceClassification.from_pretrained( args.predictor_model, trust_remote_code=True, torch_dtype=dtype, ) device = "cuda" if torch.cuda.is_available() else "cpu" model.to(device) model.eval() return tokenizer, model, device def predict_scores(sequences: Sequence[str], tokenizer, model, device: str, max_length: int, batch_size: int) -> List[List[float]]: outputs: List[List[float]] = [] for start in range(0, len(sequences), batch_size): batch = list(sequences[start : start + batch_size]) enc = tokenizer( batch, add_special_tokens=True, padding=True, truncation=True, max_length=max_length, return_tensors="pt", ) enc.pop("token_type_ids", None) enc = enc.to(device) with torch.inference_mode(): logits = model(**enc).logits outputs.extend(logits.detach().float().cpu().tolist()) return outputs def build_generation_rows(args, tokenizer, model, base_ids, id_to_base, device) -> List[Dict[str, Any]]: rows: List[Dict[str, Any]] = [] bucket_schedule = [] for bucket in BUCKET_ORDER: bucket_schedule.extend([bucket] * args.num_per_bucket) for start in range(0, len(bucket_schedule), args.batch_size): batch_buckets = bucket_schedule[start : start + args.batch_size] sequences = iterative_unmask( model=model, tokenizer=tokenizer, buckets=batch_buckets, args=args, base_ids=base_ids, id_to_base=id_to_base, device=device, ) for bucket, sequence in zip(batch_buckets, sequences): rows.append( { "source": "generated", "activity_bucket": bucket, "condition_token": BUCKET_TOKENS[bucket], "generated_sequence": sequence, "valid_dna": set(sequence).issubset(set(DNA_BASES)), "generated_bp_length": len(sequence), } ) return rows def build_reference_rows(args, reference_df: pd.DataFrame) -> List[Dict[str, Any]]: rows: List[Dict[str, Any]] = [] rng = np.random.default_rng(args.seed) for bucket in BUCKET_ORDER: bucket_df = reference_df[reference_df["activity_bucket"] == bucket] sample_n = min(args.num_per_bucket, len(bucket_df)) if sample_n == 0: continue indices = rng.choice(bucket_df.index.to_numpy(), size=sample_n, replace=False) for _, row in bucket_df.loc[indices].iterrows(): sequence = str(row[args.sequence_col])[: args.sequence_length] rows.append( { "source": "reference", "activity_bucket": bucket, "condition_token": BUCKET_TOKENS[bucket], "generated_sequence": sequence, "valid_dna": set(sequence).issubset(set(DNA_BASES)), "generated_bp_length": len(sequence), "source_id": str(row.get("id", "")), "source_label": normalize_label(row[args.label_col]), } ) return rows def attach_scores(rows: List[Dict[str, Any]], predictor_tokenizer, predictor_model, predictor_device: str, args): sequences = [row["generated_sequence"] for row in rows] scores = predict_scores( sequences, tokenizer=predictor_tokenizer, model=predictor_model, device=predictor_device, max_length=args.max_length, batch_size=args.predictor_batch_size, ) for row, score in zip(rows, scores): row["prediction"] = score row["prediction_label_0"] = float(score[0]) row["prediction_label_1"] = float(score[1]) row["prediction_sum"] = float(sum(score)) row["score_source"] = "predictor" def encode_conditioned_sequence(tokenizer, bucket: str, sequence: str, conditioned: bool) -> List[int]: prefix_ids: List[int] = [] if conditioned: prefix_ids = tokenizer(BUCKET_TOKENS[bucket], add_special_tokens=False)["input_ids"] body_ids = tokenizer(sequence, add_special_tokens=False)["input_ids"] return tokenizer.build_inputs_with_special_tokens(prefix_ids + body_ids) def score_sequences_with_diffusion( rows: List[Dict[str, Any]], tokenizer, model, device: str, conditioned: bool, base_ids: Sequence[int], max_length: int, batch_size: int, chunk_size: int, ): base_id_set = set(int(token_id) for token_id in base_ids) mask_id = tokenizer.mask_token_id pad_id = tokenizer.pad_token_id if tokenizer.pad_token_id is not None else tokenizer.eos_token_id model.eval() for start in range(0, len(rows), batch_size): batch_rows = rows[start : start + batch_size] encoded_rows = [] base_positions_rows = [] for row in batch_rows: token_ids = encode_conditioned_sequence( tokenizer, bucket=row["activity_bucket"], sequence=row["generated_sequence"][:max_length], conditioned=conditioned, )[:max_length] base_positions = [idx for idx, token_id in enumerate(token_ids) if int(token_id) in base_id_set] encoded_rows.append(torch.tensor(token_ids, dtype=torch.long)) base_positions_rows.append(base_positions) max_len = max(item.numel() for item in encoded_rows) input_ids = torch.full((len(encoded_rows), max_len), int(pad_id), dtype=torch.long) attention_mask = torch.zeros_like(input_ids) for row_idx, token_ids in enumerate(encoded_rows): input_ids[row_idx, : token_ids.numel()] = token_ids attention_mask[row_idx, : token_ids.numel()] = 1 logprob_sums = [0.0 for _ in batch_rows] token_counts = [0 for _ in batch_rows] for chunk_start in range(0, max((len(pos) for pos in base_positions_rows), default=0), chunk_size): masked_input = input_ids.clone() selected_positions_rows = [] for row_idx, positions in enumerate(base_positions_rows): selected = positions[chunk_start : chunk_start + chunk_size] selected_positions_rows.append(selected) if selected: masked_input[row_idx, selected] = mask_id if not any(selected_positions_rows): continue with torch.inference_mode(): logits = model( input_ids=masked_input.to(device), attention_mask=attention_mask.to(device), ).logits.detach().float().cpu() log_probs = torch.log_softmax(logits, dim=-1) for row_idx, selected in enumerate(selected_positions_rows): for pos in selected: true_id = int(input_ids[row_idx, pos].item()) logprob_sums[row_idx] += float(log_probs[row_idx, pos, true_id].item()) token_counts[row_idx] += 1 for row, total, count in zip(batch_rows, logprob_sums, token_counts): score = total / count if count else float("nan") row["prediction"] = [score] row["prediction_sum"] = score row["diffusion_pll"] = score row["score_source"] = "diffusion_pll" def summarise(rows: List[Dict[str, Any]]) -> Dict[str, Any]: summary: Dict[str, Any] = {"num_rows": len(rows)} for source in ["generated", "reference"]: source_rows = [row for row in rows if row["source"] == source] if not source_rows: continue summary[source] = { "num_rows": len(source_rows), "valid_dna_rate": sum(1 for row in source_rows if row["valid_dna"]) / len(source_rows), "unique_rate": len({row["generated_sequence"] for row in source_rows}) / len(source_rows), "mean_prediction_sum": sum(row["prediction_sum"] for row in source_rows) / len(source_rows), } if all("prediction_label_0" in row for row in source_rows): summary[source]["mean_prediction_label_0"] = sum(row["prediction_label_0"] for row in source_rows) / len(source_rows) summary[source]["mean_prediction_label_1"] = sum(row["prediction_label_1"] for row in source_rows) / len(source_rows) by_bucket = {} for bucket in BUCKET_ORDER: bucket_rows = [row for row in source_rows if row["activity_bucket"] == bucket] if not bucket_rows: continue by_bucket[bucket] = { "num_rows": len(bucket_rows), "valid_dna_rate": sum(1 for row in bucket_rows if row["valid_dna"]) / len(bucket_rows), "unique_rate": len({row["generated_sequence"] for row in bucket_rows}) / len(bucket_rows), "mean_prediction_sum": sum(row["prediction_sum"] for row in bucket_rows) / len(bucket_rows), } if all("prediction_label_0" in row for row in bucket_rows): by_bucket[bucket]["mean_prediction_label_0"] = sum(row["prediction_label_0"] for row in bucket_rows) / len(bucket_rows) by_bucket[bucket]["mean_prediction_label_1"] = sum(row["prediction_label_1"] for row in bucket_rows) / len(bucket_rows) summary[source]["by_activity_bucket"] = by_bucket return summary def save_jsonl(path: Path, rows: Sequence[Dict[str, Any]]): with open(path, "w", encoding="utf-8") as f: for row in rows: f.write(json.dumps(row, ensure_ascii=False) + "\n") def plot_violin(rows: List[Dict[str, Any]], output_path: Path): fig, ax = plt.subplots(figsize=(9, 5), dpi=180) positions = [] data = [] labels = [] colors = [] for bucket_idx, bucket in enumerate(BUCKET_ORDER): for source_idx, source in enumerate(["reference", "generated"]): values = [ row["prediction_sum"] for row in rows if row["activity_bucket"] == bucket and row["source"] == source ] if not values: continue positions.append(bucket_idx * 3 + source_idx) data.append(values) labels.append(f"{bucket}\n{source}") colors.append("#6f8fc9" if source == "reference" else "#d87c4a") parts = ax.violinplot(data, positions=positions, showmeans=True, showextrema=False) for body, color in zip(parts["bodies"], colors): body.set_facecolor(color) body.set_alpha(0.55) body.set_edgecolor("#333333") if "cmeans" in parts: parts["cmeans"].set_color("#111111") parts["cmeans"].set_linewidth(1.2) ax.set_xticks(positions) ax.set_xticklabels(labels) ax.set_ylabel("Predictor score sum") ax.set_title("Predictor score distribution by activity bucket") ax.grid(axis="y", alpha=0.25) fig.tight_layout() fig.savefig(output_path) plt.close(fig) def plot_bucket_bar(summary: Dict[str, Any], output_path: Path): generated = summary.get("generated", {}).get("by_activity_bucket", {}) reference = summary.get("reference", {}).get("by_activity_bucket", {}) x = np.arange(len(BUCKET_ORDER)) width = 0.34 gen_values = [generated.get(bucket, {}).get("mean_prediction_sum", np.nan) for bucket in BUCKET_ORDER] ref_values = [reference.get(bucket, {}).get("mean_prediction_sum", np.nan) for bucket in BUCKET_ORDER] fig, ax = plt.subplots(figsize=(7.5, 4.5), dpi=180) ax.bar(x - width / 2, ref_values, width, label="reference", color="#6f8fc9") ax.bar(x + width / 2, gen_values, width, label="generated", color="#d87c4a") ax.set_xticks(x) ax.set_xticklabels(BUCKET_ORDER) ax.set_ylabel("Mean sequence score") ax.set_title("Sequence score by activity bucket") ax.grid(axis="y", alpha=0.25) ax.legend(frameon=False) fig.tight_layout() fig.savefig(output_path) plt.close(fig) def main(): args = parse_args() random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) dtype = resolve_dtype(args) diffusion_tokenizer, diffusion_model, diffusion_device = load_diffusion_model(args, dtype) base_ids, id_to_base = get_base_ids(diffusion_tokenizer) generated_rows = build_generation_rows( args, tokenizer=diffusion_tokenizer, model=diffusion_model, base_ids=base_ids, id_to_base=id_to_base, device=diffusion_device, ) reference_df = load_bucketed_reference(args) reference_rows = build_reference_rows(args, reference_df) all_rows = generated_rows + reference_rows predictor_tokenizer, predictor_model, predictor_device = load_predictor(args, dtype) if predictor_model is not None: attach_scores(all_rows, predictor_tokenizer, predictor_model, predictor_device, args) score_source = "predictor" else: score_sequences_with_diffusion( all_rows, tokenizer=diffusion_tokenizer, model=diffusion_model, device=diffusion_device, conditioned=args.conditioned, base_ids=base_ids, max_length=args.max_length, batch_size=args.score_batch_size, chunk_size=args.pll_chunk_size, ) score_source = "diffusion_pll" summary = summarise(all_rows) summary.update( { "diffusion_model": args.diffusion_model, "predictor_model": args.predictor_model, "score_source": score_source, "dataset_dir": args.dataset_dir, "split": args.split, "conditioned": args.conditioned, "sequence_length": args.sequence_length, "num_diffusion_steps": args.num_diffusion_steps, } ) save_jsonl(output_dir / "diffusion_scoring_details.jsonl", all_rows) with open(output_dir / "diffusion_scoring_summary.json", "w", encoding="utf-8") as f: json.dump(summary, f, indent=2, ensure_ascii=False) plot_bucket_bar(summary, output_dir / "bucket_score_bar.png") if predictor_model is not None: plot_violin(all_rows, output_dir / "bucket_predictor_score_violin.png") logger.info("Saved evaluation outputs to %s", output_dir) if __name__ == "__main__": main()