utils.py

"""
Utilities for the Transcription Factor Binding (TFB) demo notebook.

This module centralizes reusable logic so the notebook stays concise:
- DeepSEA-style dataset wrapper around OmniDataset
- Tokenizer and model loader for multi-label classification
- Dataset and DataLoader builders
- Training, evaluation, and simple inference helpers
"""
import zipfile
from typing import Optional, List, Dict, Any

import os
import json
import requests
import torch
import torch.nn as nn
import findfile

from transformers import AutoTokenizer, AutoModel

from omnigenbench import (
    OmniDataset,
    ClassificationMetric,
    AccelerateTrainer,
    ModelHub,
    OmniModelForMultiLabelSequenceClassification,
    OmniModel,
    # Import integrated baselines from the package
    OmniCNNBaseline,
    OmniRNNBaseline,
    OmniBasenjiBaseline,
    OmniBPNetBaseline,
    OmniDeepSTARRBaseline,
)


# ---------------- New helpers for 1D-conv baselines ----------------
class _TokenIdsToOneHot4(nn.Module):
    """Map tokenizer input_ids [B,L] to one-hot channels [B,4,L] for A,C,G,T.

    Unknown tokens (including N and pads) map to all-zero columns.
    """
    def __init__(self, tokenizer):
        super().__init__()
        vocab = tokenizer.get_vocab() if hasattr(tokenizer, "get_vocab") else {}
        # Build mapping id->channel for A,C,G,T (0..3), else -1
        token_to_channel = {"A": 0, "C": 1, "G": 2, "T": 3, "a": 0, "c": 1, "g": 2, "t": 3}
        vocab_size = len(vocab) if vocab else getattr(tokenizer, "vocab_size", 0) or 0
        mapping = torch.full((max(vocab_size, 1),), fill_value=-1, dtype=torch.long)
        if vocab:
            for tok, idx in vocab.items():
                if tok in token_to_channel:
                    mapping[idx] = token_to_channel[tok]
        else:
            # Fallback: try direct ids for single-letter tokens
            for ch, ch_idx in token_to_channel.items():
                try:
                    idx = tokenizer.convert_tokens_to_ids(ch)
                    if isinstance(idx, int) and idx >= 0:
                        if idx >= mapping.numel():
                            # expand mapping tensor if tokenizer reports larger id
                            new_map = torch.full((idx + 1,), fill_value=-1, dtype=torch.long)
                            new_map[: mapping.numel()] = mapping
                            mapping = new_map
                        mapping[idx] = ch_idx
                except Exception:
                    pass
        self.register_buffer("id2chan", mapping)

    def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
        # input_ids: [B,L]
        if input_ids.dtype != torch.long:
            input_ids = input_ids.long()
        vocab_to_channel = self.id2chan
        max_id = int(input_ids.max().item()) if input_ids.numel() > 0 else -1
        if max_id >= vocab_to_channel.numel():
            # Expand mapping lazily with -1 for unknown new ids
            new_map = torch.full((max_id + 1,), fill_value=-1, dtype=torch.long, device=vocab_to_channel.device)
            new_map[: vocab_to_channel.numel()] = vocab_to_channel
            self.id2chan = new_map  # type: ignore[attr-defined]
            vocab_to_channel = self.id2chan
        idx = vocab_to_channel[input_ids]
        # Map unknown (-1) to 4 then one-hot num_classes=5 and slice first 4
        idx_clamped = idx.clamp(min=-1)
        idx_clamped = torch.where(idx_clamped < 0, torch.full_like(idx_clamped, 4), idx_clamped)
        one_hot5 = torch.nn.functional.one_hot(idx_clamped, num_classes=5).to(torch.float32)
        x = one_hot5[..., :4].permute(0, 2, 1).contiguous()  # [B,4,L]
        return x


def download_deepsea_dataset(local_dir):
    if not findfile.find_cwd_dir(local_dir, disable_alert=True):
        os.makedirs(local_dir, exist_ok=True)
    # else:
    #     return
    url_to_download = "https://huggingface.co/datasets/yangheng/deepsea_tfb_prediction/resolve/main/deepsea_tfb_prediction.zip"
    zip_path = os.path.join(local_dir, "deepsea_tfb_prediction.zip")
    if not os.path.exists(zip_path):
        print(f"Downloading deepsea_tfb_prediction.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("deepsea_tfb_prediction.zip")
    if ZIP_DATASET:
        with zipfile.ZipFile(ZIP_DATASET, 'r') as zip_ref:
            zip_ref.extractall(local_dir)
        print(f"Extracted deepsea_tfb_prediction.zip into {local_dir}")
        os.remove(ZIP_DATASET)
    else:
        print("deepsea_tfb_prediction.zip not found. Skipping extraction.")


class DeepSEADataset(OmniDataset):
    """
    A dataset for the DeepSEA task that converts DNA sequences to tokenized inputs.
    Accepts JSONL where each line contains a `sequence` field and `label(s)`.
    """

    def __init__(
        self,
        data_source: str,
        tokenizer,
        max_length: Optional[int] = None,
        **kwargs,
    ) -> None:
        super().__init__(data_source, tokenizer, max_length, **kwargs)
        self.label_indices = None
        for key, value in kwargs.items():
            self.metadata[key] = value

    def prepare_input(self, instance: Dict[str, Any], **kwargs) -> Dict[str, torch.Tensor]:
        def truncate(seq: str, windowsize: Optional[int]) -> str:
            if windowsize is None:
                return seq
            if len(seq) == windowsize:
                return seq
            if len(seq) > windowsize:
                left = (len(seq) - windowsize) // 2
                return seq[left:left + windowsize]
            return seq + ("N" * (windowsize - len(seq)))

        sequence = instance.get('sequence') or instance.get('seq')
        labels = instance.get('label', None) if 'label' in instance else instance.get('labels', None)

        tokenized_inputs = self.tokenizer(
            truncate(sequence, self.max_length),
            padding="do_not_pad",
            truncation=True,
            max_length=self.max_length,
            return_tensors="pt",
            **kwargs,
        )

        labels_tensor = torch.tensor(labels, dtype=torch.float32) if labels is not None else None
        if labels_tensor is not None and hasattr(self, 'label_indices') and self.label_indices is not None:
            labels_tensor = labels_tensor[torch.tensor(self.label_indices, dtype=torch.long)]
        tokenized_inputs["labels"] = labels_tensor

        for col in tokenized_inputs:
            if isinstance(tokenized_inputs[col], torch.Tensor) and tokenized_inputs[col].ndim > 1:
                tokenized_inputs[col] = tokenized_inputs[col].squeeze(0)

        return tokenized_inputs


def load_tokenizer_and_model(
    model_name_or_path: str,
    num_labels: int,
    threshold: float = 0.5,
    device: Optional[torch.device] = None,
):
    """
    Load tokenizer and OmniGenome-based multi-label classification model.
    """
    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)
    base_model = AutoModel.from_pretrained(model_name_or_path, trust_remote_code=True)

    model = OmniModelForMultiLabelSequenceClassification(
        base_model,
        tokenizer,
        num_labels=num_labels,
        threshold=threshold,
    )
    if device is not None:
        model = model.to(device).to(torch.float32)

    return tokenizer, model


def build_datasets(
    tokenizer,
    train_file: str,
    test_file: str,
    valid_file: Optional[str],
    max_length: int,
    max_examples: Optional[int],
    label_indices: Optional[List[int]] = None,
):
    """
    Create DeepSEADataset instances for train/valid/test.
    """
    def make_ds(path: str) -> DeepSEADataset:
        ds = DeepSEADataset(
            data_source=path,
            tokenizer=tokenizer,
            max_length=max_length,
            max_examples=max_examples,
            force_padding=False,
        )
        # attach label indices for internal selection
        ds.label_indices = label_indices
        return ds

    train_set = make_ds(train_file)
    test_set = make_ds(test_file)
    valid_set = make_ds(valid_file) if (valid_file and os.path.exists(valid_file)) else None
    return train_set, valid_set, test_set


def create_dataloaders(
    train_set: torch.utils.data.Dataset,
    valid_set: Optional[torch.utils.data.Dataset],
    test_set: Optional[torch.utils.data.Dataset],
    batch_size: int,
):
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)
    test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size) if test_set is not None else None
    valid_loader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size) if valid_set is not None else None
    return train_loader, valid_loader, test_loader


def run_finetuning(
    model: torch.nn.Module,
    train_loader,
    valid_loader,
    test_loader,
    epochs: int,
    learning_rate: float,
    weight_decay: float,
    patience: int,
    device: torch.device,
    save_dir: str = "tfb_model",
    seed: Optional[int] = 2024,
):
    """
    Train the model with AccelerateTrainer and save to `save_dir`.
    Returns the trainer and the best metrics.
    """
    metric_fn = [ClassificationMetric(ignore_y=-100).roc_auc_score]
    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=weight_decay)

    trainer = AccelerateTrainer(
        model=model,
        train_loader=train_loader,
        eval_loader=valid_loader,
        test_loader=test_loader,
        optimizer=optimizer,
        epochs=epochs,
        compute_metrics=metric_fn,
        patience=patience,
        device=device,
        seed=seed,
    )

    metrics_best = None
    if not os.path.exists(save_dir):
        metrics_best = trainer.train()
        trainer.save_model(save_dir)
    else:
        metrics_best = {"info": f"Found existing '{save_dir}'. Skipped training."}

    return trainer, metrics_best



def run_inference(
    model_dir: str,
    tokenizer,
    sample_sequence: str,
    max_length: int,
    device: torch.device,
):
    """
    Load a saved model via ModelHub and run a single-sequence inference.
    Returns a dict containing predictions and probabilities when available.
    """
    model = ModelHub.load(model_dir)
    model.to(device)

    inputs = tokenizer(sample_sequence, return_tensors="pt", max_length=max_length, truncation=True)
    inputs = inputs.to(torch.float32)
    with torch.no_grad():
        outputs = model.inference(inputs, device=device)
    return outputs


class _MaskedGlobalMaxPool1d(nn.Module):
    def forward(self, x: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
        if attention_mask is None:
            return x.max(dim=1).values
        masked_x = x.masked_fill(attention_mask.unsqueeze(-1).eq(0), float("-inf"))
        return masked_x.max(dim=1).values


__all__ = [
    "DeepSEADataset",
    "load_tokenizer_and_model",
    "build_datasets",
    "create_dataloaders",
    "run_finetuning",
    "run_inference",
    "OmniCNNBaseline",
    "OmniRNNBaseline",
    "OmniBPNetBaseline",
    "OmniBasenjiBaseline",
    "OmniDeepSTARRBaseline",
]