multi_omics_transcript_expression.py

import gzip
import logging
import os
import re
import shutil
import ssl
import urllib
from abc import ABC, abstractmethod
from pathlib import Path
from typing import List

import datasets
import pandas as pd
from datasets import DatasetInfo
from pyfaidx import Fasta
from tqdm import tqdm

ssl._create_default_https_context = ssl._create_unverified_context

"""
--------------------------------------------------------------------------------------------
Reference Genome URLS:
-------------------------------------------------------------------------------------------
"""
H38_REFERENCE_GENOME_URL = (
    "https://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/" "hg38.fa.gz"
)

"""
--------------------------------------------------------------------------------------------
Task Specific Handlers:
-------------------------------------------------------------------------------------------
"""

logger = logging.getLogger("multi_omics_transcript_expression")
logger.setLevel("INFO")

LABELS_V1 = [
    "Adipose Tissue",
    "Adrenal Gland",
    "Bladder",
    "Blood",
    "Blood Vessel",
    "Brain",
    "Breast",
    "Cervix Uteri",
    "Colon",
    "Esophagus",
    "Fallopian Tube",
    "Heart",
    "Kidney",
    "Liver",
    "Lung",
    "Muscle",
    "Nerve",
    "Ovary",
    "Pancreas",
    "Pituitary",
    "Prostate",
    "Salivary Gland",
    "Skin",
    "Small Intestine",
    "Spleen",
    "Stomach",
    "Testis",
    "Thyroid",
    "Uterus",
    "Vagina",
]

LABELS_V2 = [
    "Adipose_Subcutaneous",
    "Adipose_Visceral (Omentum)",
    "Adrenal Gland",
    "Artery_Aorta",
    "Artery_Coronary",
    "Artery_Tibial",
    "Bladder",
    "Brain_Amygdala",
    "Brain_Anterior cingulate cortex (BA24)",
    "Brain_Caudate (basal ganglia)",
    "Brain_Cerebellar Hemisphere",
    "Brain_Cerebellum",
    "Brain_Cortex",
    "Brain_Frontal Cortex (BA9)",
    "Brain_Hippocampus",
    "Brain_Hypothalamus",
    "Brain_Nucleus accumbens (basal ganglia)",
    "Brain_Putamen (basal ganglia)",
    "Brain_Spinal cord (cervical c-1)",
    "Brain_Substantia nigra",
    "Breast_Mammary Tissue",
    "Cells_Cultured fibroblasts",
    "Cells_EBV-transformed lymphocytes",
    "Cervix_Ectocervix",
    "Cervix_Endocervix",
    "Colon_Sigmoid",
    "Colon_Transverse",
    "Esophagus_Gastroesophageal Junction",
    "Esophagus_Mucosa",
    "Esophagus_Muscularis",
    "Fallopian Tube",
    "Heart_Atrial Appendage",
    "Heart_Left Ventricle",
    "Kidney_Cortex",
    "Kidney_Medulla",
    "Liver",
    "Lung",
    "Minor Salivary Gland",
    "Muscle_Skeletal",
    "Nerve_Tibial",
    "Ovary",
    "Pancreas",
    "Pituitary",
    "Prostate",
    "Skin_Not Sun Exposed (Suprapubic)",
    "Skin_Sun Exposed (Lower leg)",
    "Small Intestine_Terminal Ileum",
    "Spleen",
    "Stomach",
    "Testis",
    "Thyroid",
    "Uterus",
    "Vagina",
    "Whole Blood",
]

# Add after LABELS_V2 definition
LABELS_LIGHT = [
    "Adipose Tissue",
    "Brain",
    "Heart",
    "Liver",
    "Lung",
    "Muscle",
    "Pancreas",
    "Skin",
]

class GenomicLRATaskHandler(ABC):
    """
    Abstract method for the Genomic LRA task handlers. Each handler
    """

    @abstractmethod
    def __init__(self, **kwargs):
        pass

    @abstractmethod
    def get_info(self, description: str) -> DatasetInfo:
        """
        Returns the DatasetInfo for the task
        """
        pass

    def split_generators(
        self, dl_manager, cache_dir_root
    ) -> List[datasets.SplitGenerator]:
        """
        Downloads required files using dl_manager and separates them by split.
        """
        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={"handler": self, "split": "train"},
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST, gen_kwargs={"handler": self, "split": "test"}
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={"handler": self, "split": "test"},
            ),
        ]

    @abstractmethod
    def generate_examples(self, split):
        """
        A generator that yields examples for the specified split.
        """
        pass

    @staticmethod
    def hook(t):
        last_b = [0]

        def inner(b=1, bsize=1, tsize=None):
            """
            b  : int, optional
                Number of blocks just transferred [default: 1].
            bsize  : int, optional
                Size of each block (in tqdm units) [default: 1].
            tsize  : int, optional
                Total size (in tqdm units). If [default: None] remains unchanged.
            """
            if tsize is not None:
                t.total = tsize
            t.update((b - last_b[0]) * bsize)
            last_b[0] = b

        return inner

    def download_and_extract_gz(self, file_url, cache_dir_root):
        """
        Downloads and extracts a gz file into the given cache directory. Returns the full file path
        of the extracted gz file.
        Args:
            file_url: url of the gz file to be downloaded and extracted.
            cache_dir_root: Directory to extract file into.
        """
        file_fname = Path(file_url).stem
        file_complete_path = os.path.join(cache_dir_root, "downloads", file_fname)

        if not os.path.exists(file_complete_path):
            if not os.path.exists(file_complete_path + ".gz"):
                os.makedirs(os.path.dirname(file_complete_path), exist_ok=True)
                with tqdm(
                    unit="B",
                    unit_scale=True,
                    unit_divisor=1024,
                    miniters=1,
                    desc=file_url.split("/")[-1],
                ) as t:
                    urllib.request.urlretrieve(
                        file_url, file_complete_path + ".gz", reporthook=self.hook(t)
                    )
            with gzip.open(file_complete_path + ".gz", "rb") as file_in:
                with open(file_complete_path, "wb") as file_out:
                    shutil.copyfileobj(file_in, file_out)
        return file_complete_path


class TranscriptExpressionHandler(GenomicLRATaskHandler):
    """
    Handler for the Transcript Expression task.
    """

    DEFAULT_LENGTH = 200_000
    DEFAULT_FILTER_OUT_LENGTH = 196_608

    def __init__(
        self,
        sequence_length: int = DEFAULT_LENGTH,
        filter_out_sequence_length: int = DEFAULT_FILTER_OUT_LENGTH,
        expression_method: str = "read_counts_old",
        light_version: bool = False,
        **kwargs,
    ):
        """
        Creates a new handler for the Transcript Expression Prediction Task.
        Args:
            sequence_length: Length of the sequence around the TSS_CAGE start site
            light_version: If True, uses a smaller subset of tissues and fewer samples
        """
        self.reference_genome = None
        self.coordinate_csv_file = None
        self.labels_csv_file = None
        self.light_version = light_version
        self.sequence_length = sequence_length
        self.filter_out_sequence_length = filter_out_sequence_length

        if self.filter_out_sequence_length is not None:
            assert isinstance(self.filter_out_sequence_length, int)
            assert (
                self.sequence_length <= self.filter_out_sequence_length
            ), f"{self.sequence_length=} > {self.filter_out_sequence_length=}"
        assert isinstance(self.sequence_length, int)

    def get_info(self, description: str) -> DatasetInfo:
        """
        Returns the DatasetInfor for the Transcript Expression dataset. Each example
        includes a genomic sequence and a list of label values.
        """
        features = datasets.Features(
            {
                # DNA sequence
                "DNA": datasets.Value("string"),
                # list of expression values in each tissue
                "labels": datasets.Sequence(datasets.Value("float32")),
                "m_t": datasets.Sequence(datasets.Value("float32")),
                "sigma_t": datasets.Sequence(datasets.Value("float32")),
                "m_g": datasets.Sequence(datasets.Value("float32")),
                "sigma_g": datasets.Sequence(datasets.Value("float32")),
                "labels_name": datasets.Sequence(datasets.Value("string")),
                # chromosome number
                "chromosome": datasets.Value(dtype="string"),
                "RNA": datasets.Value("string"),
                "five_prime_utr": datasets.Value("string"),
                "coding_sequence": datasets.Value("string"),
                "three_prime_utr": datasets.Value("string"),
                "Protein": datasets.Value("string"),
                "transcript_id": datasets.Value("string"),
                "gene_id": datasets.Value("string"),
            }
        )
        return datasets.DatasetInfo(
            description=description,
            features=features,
        )

    def split_generators(self, dl_manager, cache_dir_root):
        """
        Separates files by split and stores filenames in instance variables.
        The Transcript Expression dataset requires the reference hg19 genome, coordinate
        csv file,and label csv file to be saved.
        """
        # Manually download the reference genome since there are difficulties when streaming
        reference_genome_file = self.download_and_extract_gz(
            H38_REFERENCE_GENOME_URL, cache_dir_root
        )
        self.reference_genome = Fasta(reference_genome_file, one_based_attributes=False)

        self.df_csv_file = dl_manager.download_and_extract(
            "transcript_expression/GTEx_final.csv"
        )
        self.normalization_values_csv_file = dl_manager.download_and_extract(
            "transcript_expression/normalization_values.csv"
        )

        return super().split_generators(dl_manager, cache_dir_root)

    def generate_examples(self, split):
        """
        A generator which produces examples for the given split, each with a sequence
        and the corresponding labels. The sequences are padded to the correct sequence
        length and standardized before returning.
        """
        df = pd.read_csv(self.df_csv_file)
        df = df.loc[df["chr"] != "chrMT"]
        
        # Use light version labels if specified
        labels_name = LABELS_LIGHT if self.light_version else LABELS_V1

        split_df = df.loc[df["split"] == split]
        
        # For light version, take only a subset of the data
        if self.light_version:
            split_df = split_df.sample(n=min(1000, len(split_df)), random_state=42)

        norm_values_df = pd.read_csv(self.normalization_values_csv_file)
        
        # Select appropriate columns based on version
        label_columns = [f"m_t_{tissue}" for tissue in labels_name]
        m_t = norm_values_df[label_columns].to_numpy().reshape(-1)
        
        label_columns = [f"sigma_t_{tissue}" for tissue in labels_name]
        sigma_t = norm_values_df[label_columns].to_numpy().reshape(-1)
        
        label_columns = [f"m_g_{tissue}" for tissue in labels_name]
        m_g = norm_values_df[label_columns].to_numpy().reshape(-1)
        
        label_columns = [f"sigma_g_{tissue}" for tissue in labels_name]
        sigma_g = norm_values_df[label_columns].to_numpy().reshape(-1)

        key = 0
        for idx, coordinates_row in split_df.iterrows():
            negative_strand = coordinates_row["strand"] == "-"

            if negative_strand:
                start = coordinates_row["end"] - 1
            else:
                start = coordinates_row["start"] - 1  # -1 since vcf coords are 1-based

            chromosome = coordinates_row["chr"]
            labels_row = coordinates_row[labels_name]
            padded_sequence = pad_sequence(
                chromosome=self.reference_genome[chromosome],
                start=start,
                sequence_length=self.sequence_length,
                negative_strand=negative_strand,
                filter_out_sequence_length=self.filter_out_sequence_length,
            )
            if padded_sequence:
                yield key, {
                    "transcript_id": coordinates_row["transcript_id_gtex"],
                    "gene_id": coordinates_row["gene_id_gtex"],
                    "labels_name": labels_name,
                    "labels": labels_row.to_numpy(),
                    "m_t": m_t,
                    "sigma_t": sigma_t,
                    "m_g": m_g,
                    "sigma_g": sigma_g,
                    "DNA": standardize_sequence(padded_sequence),
                    "chromosome": re.sub("chr", "", chromosome),
                    "RNA": coordinates_row["RNA"],
                    "five_prime_utr": coordinates_row["5UTR"],
                    "coding_sequence": coordinates_row["CDS"],
                    "three_prime_utr": coordinates_row["3UTR"],
                    "Protein": coordinates_row["Protein"],
                }
                key += 1
        logger.info(f"filtering out {len(split_df)-key} " f"elements from the dataset")


"""
--------------------------------------------------------------------------------------------
Dataset loader:
-------------------------------------------------------------------------------------------
"""

_DESCRIPTION = """
Dataset for benchmark of genomic deep learning models. 
"""


# define dataset configs
class GenomicsLRAConfig(datasets.BuilderConfig):
    """
    BuilderConfig.
    """

    def __init__(self, *args, **kwargs):  # type: ignore
        """BuilderConfig for the location tasks dataset.
        Args:
            **kwargs: keyword arguments forwarded to super.
        """
        super().__init__()
        self.handler = TranscriptExpressionHandler(**kwargs)


# DatasetBuilder
class GenomicsLRATasks(datasets.GeneratorBasedBuilder):
    """
    Tasks to annotate human genome.
    """

    VERSION = datasets.Version("1.1.0")
    BUILDER_CONFIG_CLASS = GenomicsLRAConfig

    def _info(self) -> DatasetInfo:
        return self.config.handler.get_info(description=_DESCRIPTION)

    def _split_generators(
        self, dl_manager: datasets.DownloadManager
    ) -> List[datasets.SplitGenerator]:
        """
        Downloads data files and organizes it into train/test/val splits
        """
        return self.config.handler.split_generators(dl_manager, self._cache_dir_root)

    def _generate_examples(self, handler, split):
        """
        Read data files and create examples(yield)
        Args:
            handler: The handler for the current task
            split: A string in ['train', 'test', 'valid']
        """
        yield from handler.generate_examples(split)


"""
--------------------------------------------------------------------------------------------
Global Utils:
-------------------------------------------------------------------------------------------
"""


def standardize_sequence(sequence: str):
    """
    Standardizes the sequence by replacing all unknown characters with N and
    converting to all uppercase.
    Args:
        sequence: genomic sequence to standardize
    """
    pattern = "[^ATCG]"
    # all characters to upper case
    sequence = sequence.upper()
    # replace all characters that are not A,T,C,G with N
    sequence = re.sub(pattern, "N", sequence)
    return sequence


def pad_sequence(
    chromosome,
    start,
    sequence_length,
    negative_strand=False,
    filter_out_sequence_length=None,
):
    """
    Extends a given sequence to length sequence_length. If
    padding to the given length is outside the gene, returns
    None.
    Args:
        chromosome: Chromosome from pyfaidx extracted Fasta.
        start: Start index of original sequence.
        sequence_length: Desired sequence length. If sequence length is odd, the
            remainder is added to the end of the sequence.
        end: End index of original sequence. If no end is specified, it creates a
            centered sequence around the start index.
        negative_strand: If negative_strand, returns the reverse compliment of the sequence
    """

    pad = sequence_length // 2
    end = start + pad + (sequence_length % 2)
    start = start - pad

    if filter_out_sequence_length is not None:
        filter_out_pad = filter_out_sequence_length // 2
        filter_out_end = start + filter_out_pad + (filter_out_sequence_length % 2)
        filter_out_start = start - filter_out_pad

        if filter_out_start < 0 or filter_out_end >= len(chromosome):
            return

    if start < 0 or end >= len(chromosome):
        return

    if negative_strand:
        return chromosome[start:end].reverse.complement.seq
    return chromosome[start:end].seq