""" Utilities for the Variant Effect Prediction (VEP) notebook. This module centralizes reusable logic so the notebook stays concise: - Reference genome download helper - Annotation loader and sequence extraction - Variant application utility - Model-agnostic embedding extractors - Main VEP analysis pipeline """ from typing import List, Tuple, Optional import os import zipfile import requests import numpy as np import pandas as pd import torch from tqdm.auto import tqdm from scipy import spatial from sklearn.metrics import roc_auc_score from transformers import AutoTokenizer, AutoModelForMaskedLM, AutoModel from Bio import SeqIO # Optional utilities used by helpers below import findfile def download_vep_dataset(local_dir): if not findfile.find_cwd_dir(local_dir, disable_alert=True): os.makedirs(local_dir, exist_ok=True) url_to_download = "https://huggingface.co/datasets/yangheng/variant_effect_prediction/resolve/main/vep_dataset.zip" zip_path = os.path.join(local_dir, "vep_dataset.zip") if not os.path.exists(zip_path): print(f"Downloading vep_dataset.zip from {url_to_download}...") response = requests.get(url_to_download, stream=True) response.raise_for_status() with open(zip_path, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"Downloaded {zip_path}") # Unzip the dataset if the zip file exists ZIP_DATASET = findfile.find_cwd_file("vep_dataset.zip") if ZIP_DATASET: with zipfile.ZipFile(ZIP_DATASET, 'r') as zip_ref: zip_ref.extractall(local_dir) print(f"Extracted vep_dataset.zip into {local_dir}") os.remove(ZIP_DATASET) else: print("vep_dataset.zip not found. Skipping extraction.") # ----------------------------- # Reference genome utilities # ----------------------------- def download_ncbi_reference_genome() -> str: """Download and extract the hg38 reference genome if not found locally. Returns: Path to the FASTA file for hg38. """ import requests import gzip import shutil found_genome = findfile.find_cwd_file(or_key=["hg38.fa", "GRCh38.primary_assembly.genome.fa"], exclude_key=[".gz"]) if found_genome: print(f"Reference genome already exists: {found_genome}") return found_genome url = "http://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz" fasta_path_gz = "hg38.fa.gz" fasta_path = "hg38.fa" print(f"Downloading reference genome from {url}...") try: response = requests.get(url, stream=True) response.raise_for_status() total_size = int(response.headers.get('content-length', 0)) with open(fasta_path_gz, 'wb') as f, tqdm(total=total_size, unit='B', unit_scale=True, desc=fasta_path_gz) as pbar: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) pbar.update(len(chunk)) except requests.RequestException as e: raise Exception(f"Failed to download reference genome: {e}") print(f"Extracting {fasta_path_gz}...") with gzip.open(fasta_path_gz, 'rb') as f_in: with open(fasta_path, 'wb') as f_out: shutil.copyfileobj(f_in, f_out) os.remove(fasta_path_gz) print(f"Reference genome ready at {fasta_path}") return fasta_path # ----------------------------- # Annotation and sequence utils # ----------------------------- class Annotation: """Handles loading variant annotations and extracting DNA sequences with context.""" def __init__(self, annotation_path: str, reference_genome_path: str, context_size: int): self.context_size = context_size self.annotation = pd.read_csv(annotation_path, sep='\t') self.annotation['orig_start'] = self.annotation['start'] self.annotation['orig_end'] = self.annotation['end'] self.annotation['variant_offset'] = self.annotation['start'] - self.annotation['orig_start'] print(f"Loading reference genome from {reference_genome_path}...") self.genome_dict = SeqIO.to_dict(SeqIO.parse(reference_genome_path, "fasta")) print(f"Loaded {len(self.genome_dict)} chromosomes.") self.extend_segments() def extend_segments(self): """Calculates new start/end coordinates to include the context window.""" df = self.annotation df['start'] = (df['orig_start'] - self.context_size).clip(lower=0) df['end'] = df['orig_end'] + self.context_size df['mutation_position'] = (df['variant_offset'] + self.context_size).astype(int) self.annotation = df def get_dna_segment(self, index: int) -> str: """Extracts a DNA segment for a given variant index.""" item = self.annotation.iloc[index] chrom = item.get('chromosome', item.get('chr')) start, end = int(item['start']), int(item['end']) if chrom not in self.genome_dict: chrom_alt = f"chr{chrom}" if not chrom.startswith('chr') else chrom.replace('chr', '') if chrom_alt in self.genome_dict: chrom = chrom_alt else: return "" seq_obj = self.genome_dict[chrom] end = min(end, len(seq_obj.seq)) return str(seq_obj.seq[start:end]).upper() def apply_variant(sequence: str, ref_allele: str, alt_allele: str, mut_pos: int) -> str: """Applies a single nucleotide variant (SNV) to a reference sequence.""" if not (len(ref_allele) == 1 and len(alt_allele) == 1): return sequence if mut_pos < 0 or mut_pos >= len(sequence): return sequence if sequence[mut_pos].upper() != ref_allele.upper(): pass return sequence[:mut_pos] + alt_allele.upper() + sequence[mut_pos + 1:] # ----------------------------- # Model tokenization/embedding # ----------------------------- def _tokenize(batch_seqs: List[str], tokenizer, context_len: int, device: torch.device, add_spaces: bool = False): return tokenizer( batch_seqs, return_tensors="pt", padding="max_length", max_length=context_len, truncation=True, add_special_tokens=False ).to(device) def _batch_extract_embeddings(batch_seqs, batch_pos, model, tokenizer, context_len, add_spaces=False): tokens = _tokenize(batch_seqs, tokenizer, context_len, model.device, add_spaces=add_spaces) with torch.no_grad(): outputs = model(input_ids=tokens['input_ids'], output_hidden_states=True) hiddens = outputs.hidden_states[-1] cls_embs, mut_embs = [], [] for j, pos in enumerate(batch_pos): cls_embs.append(hiddens[j, 0, :].cpu()) mut_embs.append(hiddens[j, pos, :].cpu()) return cls_embs, mut_embs def compute_batch_omnigenome_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): cls_embs, mut_embs = [], [] for i in tqdm(range(0, len(sequences), batch_size), desc="OmniGenome"): batch_seqs = sequences[i:i + batch_size] batch_pos = mut_positions[i:i + batch_size] c, m = _batch_extract_embeddings(batch_seqs, batch_pos, model, tokenizer, context_length, add_spaces=True) cls_embs.extend(c) mut_embs.extend(m) return cls_embs, mut_embs def compute_batch_dnabert_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): cls_embs, mut_embs = [], [] for i in tqdm(range(0, len(sequences), batch_size), desc="DNABERT"): batch_seqs = sequences[i:i + batch_size] batch_pos = mut_positions[i:i + batch_size] c, m = _batch_extract_embeddings(batch_seqs, batch_pos, model, tokenizer, context_length, add_spaces=False) cls_embs.extend(c) mut_embs.extend(m) return cls_embs, mut_embs def compute_batch_hyena_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): cls_embs, mut_embs = [], [] for i in tqdm(range(0, len(sequences), batch_size), desc="HyenaDNA"): batch_seqs = sequences[i:i + batch_size] batch_pos = mut_positions[i:i + batch_size] c, m = _batch_extract_embeddings(batch_seqs, batch_pos, model, tokenizer, context_length, add_spaces=False) cls_embs.extend(c) mut_embs.extend(m) return cls_embs, mut_embs def compute_batch_nucleotide_transformer_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): k = 6 # 6-mer tokenizer cls_embs, mut_embs = [], [] for i in tqdm(range(0, len(sequences), batch_size), desc="Nucleotide Transformer"): batch_seqs = sequences[i:i + batch_size] batch_pos = mut_positions[i:i + batch_size] tok_pos = [p // k for p in batch_pos] c, m = _batch_extract_embeddings(batch_seqs, tok_pos, model, tokenizer, context_length // k, add_spaces=False) cls_embs.extend(c) mut_embs.extend(m) return cls_embs, mut_embs def compute_batch_splice_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): return compute_batch_dnabert_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size) def compute_batch_multimolecule_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size): return compute_batch_omnigenome_outputs(sequences, mut_positions, context_length, model, tokenizer, batch_size) # ----------------------------- # Main VEP analysis # ----------------------------- def run_vep_analysis( model_name: str, bed_file: str, fasta_file: Optional[str], context_size: int, batch_size: int, max_examples: int, device: torch.device, max_variants: Optional[int] = None, ) -> pd.DataFrame: """Main pipeline for running the Variant Effect Prediction analysis. Args: model_name: Hugging Face model id or local path bed_file: Path to BED/TSV file fasta_file: Path to reference genome (if None, will attempt to download hg38) context_size: Context size in base pairs on each side batch_size: Inference batch size device: torch device max_variants: Optional subsample size Returns: DataFrame with distances and optional AUC. """ # 1. Setup Device and Check Files print("--- Step 1: Initializing ---") if not fasta_file: print("Reference genome not found. Attempting to download...") fasta_file = download_ncbi_reference_genome() if not os.path.exists(bed_file): raise FileNotFoundError(f"BED file not found at: {bed_file}") # 2. Load Genomic Annotation print("--- Step 2: Loading Annotations ---") genome_annotation = Annotation(bed_file, fasta_file, context_size) df = genome_annotation.annotation if max_variants is not None: df = df.sample(n=max_variants, random_state=42).reset_index(drop=True) print(f"Processing {len(df)} variants (truncated to max_variants={max_variants}).") else: print(f"Processing {len(df)} variants.") # 3. Load Model and Tokenizer print(f"--- Step 3: Loading Model: {model_name} ---") if "multimolecule" in model_name.lower(): from multimolecule import AutoModelForTokenPrediction, RnaTokenizer model_loader = AutoModelForTokenPrediction tokenizer = RnaTokenizer.from_pretrained(model_name, trust_remote_code=True) elif 'dnabert' in model_name.lower() or 'nucleotide-transformer' in model_name.lower(): model_loader = AutoModelForMaskedLM from omnigenbench import OmniTokenizer tokenizer = OmniTokenizer.from_pretrained(model_name, trust_remote_code=True) else: model_loader = AutoModel from omnigenbench import OmniTokenizer tokenizer = OmniTokenizer.from_pretrained(model_name, trust_remote_code=True) model = model_loader.from_pretrained(model_name, trust_remote_code=True) if hasattr(model, 'base_model'): model = model.base_model model.to(device).eval().half() print(f"Model loaded on {device} with {sum(p.numel() for p in model.parameters()):} parameters.") # 4. Select the correct embedding function model_name_lower = model_name.lower() if 'omnigenome' in model_name_lower: compute_func = compute_batch_omnigenome_outputs elif 'dnabert' in model_name_lower: compute_func = compute_batch_dnabert_outputs elif 'hyenadna' in model_name_lower: compute_func = compute_batch_hyena_outputs elif 'nucleotide-transformer' in model_name_lower: compute_func = compute_batch_nucleotide_transformer_outputs elif 'splice' in model_name_lower: compute_func = compute_batch_splice_outputs elif 'multimolecule' in model_name_lower: compute_func = compute_batch_multimolecule_outputs else: raise ValueError(f"No compute function found for model: {model_name}") # 5. Generate Reference and Alternative Sequences print("--- Step 4: Generating Sequences ---") seq_ref_list, seq_alt_list, mut_pos_list, valid_indices = [], [], [], [] for idx, item in tqdm(df.iterrows(), total=len(df), desc="Generating Sequences"): seq_ref = genome_annotation.get_dna_segment(idx) if not seq_ref: continue mut_pos = int(item['mutation_position']) seq_alt = apply_variant(seq_ref, item['ref'], item['alt'], mut_pos) if len(seq_ref_list) > max_examples: break seq_ref_list.append(seq_ref) seq_alt_list.append(seq_alt) mut_pos_list.append(mut_pos) valid_indices.append(idx) # 6. Compute Embeddings print("--- Step 5: Computing Embeddings ---") context_length = context_size * 2 r_cls, r_mut = compute_func(seq_ref_list, mut_pos_list, context_length, model, tokenizer, batch_size) a_cls, a_mut = compute_func(seq_alt_list, mut_pos_list, context_length, model, tokenizer, batch_size) # 7. Calculate Distances and Finalize Results print("--- Step 6: Calculating Scores ---") results = [] def norm(x): return x / (torch.linalg.norm(x) + 1e-8) for i, original_idx in enumerate(valid_indices): cls_dist = spatial.distance.cosine(norm(a_cls[i]), norm(r_cls[i])) mut_dist = spatial.distance.cosine(norm(a_mut[i]), norm(r_mut[i])) row = df.loc[original_idx].to_dict() row.update({'cls_dist': cls_dist, 'mut_dist': mut_dist}) results.append(row) results_df = pd.DataFrame(results) if 'label' in results_df.columns: overall_auc = roc_auc_score(results_df['label'], results_df['mut_dist']) print(f"Overall AUC based on 'mut_dist': {overall_auc:.4f}") results_df['overall_auc'] = overall_auc return results_df __all__ = [ 'download_ncbi_reference_genome', 'Annotation', 'apply_variant', 'run_vep_analysis', "compute_batch_omnigenome_outputs", "compute_batch_dnabert_outputs", "compute_batch_hyena_outputs", "compute_batch_nucleotide_transformer_outputs", "compute_batch_splice_outputs", "compute_batch_multimolecule_outputs", 'download_vep_dataset', ]