Create genomics-long-range-benchmark.py

genomics-long-range-benchmark.py

@@ -0,0 +1,530 @@
+import gzip
+import os
+import shutil
+import urllib
+from pathlib import Path
+from typing import List
+from tqdm import tqdm
+from ast import literal_eval
+
+import re
+import datasets
+import numpy as np
+import pandas as pd
+from datasets import DatasetInfo
+from pyfaidx import Fasta
+from abc import ABC, abstractmethod
+from Bio.Seq import Seq
+from Bio import SeqIO
+import pysam
+
+"""
+--------------------------------------------------------------------------------------------
+Reference Genome URLS:
+-------------------------------------------------------------------------------------------
+"""
+H38_REFERENCE_GENOME_URL = (
+    "https://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/" "hg38.fa.gz"
+)
+H19_REFERENCE_GENOME_URL = (
+    "https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/" "hg19.fa.gz"
+)
+
+"""
+--------------------------------------------------------------------------------------------
+Task Specific Handlers:
+-------------------------------------------------------------------------------------------
+"""
+
+class GenomicLRATaskHandler(ABC):
+    """
+    Abstract method for the Genomic LRA task handlers.
+    """
+
+    @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"}
+            ),
+        ]
+
+    @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"):
+                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 CagePredictionHandler(GenomicLRATaskHandler):
+    """
+    Handler for the CAGE prediction task.
+    """
+
+    NUM_TRAIN = 33891
+    NUM_TEST = 1922
+    NUM_VALID = 2195
+    DEFAULT_LENGTH = 114688  # 896 x 128bp
+    TARGET_SHAPE = (
+        896,
+        50,
+    )  # 50 is a subset of CAGE tracks from the original enformer dataset
+    NPZ_SPLIT = 1000  # number of files per npz file.
+    NUM_BP_PER_BIN = 128 # number of base pairs per bin in labels
+
+    def __init__(self, sequence_length=DEFAULT_LENGTH, **kwargs):
+        """
+        Creates a new handler for the CAGE task.
+        Args:
+            sequence_length: allows for increasing sequence context. Sequence length must be a multiple of 128 to align with binned labels. Note: increasing
+            sequence length may decrease the number of usable samples.
+        """
+        self.reference_genome = None
+        self.coordinate_csv_file = None
+        self.target_files_by_split = {}
+
+        assert (sequence_length // 128) % 2 == 0, (
+            f"Requested sequence length must be an even multuple of 128 to align with the binned labels."
+        )
+
+        self.sequence_length = sequence_length
+
+        if self.sequence_length < self.DEFAULT_LENGTH:
+
+            self.TARGET_SHAPE = (self.sequence_length//128,50)
+    
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the CAGE dataset. Each example
+        includes a genomic sequence and a 2D array of labels
+        """
+        features = datasets.Features(
+            {
+                # DNA sequence
+                "sequence": datasets.Value("string"),
+                # array of sequence length x num_labels
+                "labels": datasets.Array2D(shape=self.TARGET_SHAPE, dtype="float32"),
+                # chromosome number
+                "chromosome":datasets.Value(dtype="string")
+            }
+        )
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=description,
+            # This defines the different columns of the dataset and their types
+            features=features,
+        )
+
+    def split_generators(self, dl_manager, cache_dir_root):
+        """
+        Separates files by split and stores filenames in instance variables.
+        The CAGE dataset requires reference genome, coordinate
+        csv file,and npy files to be saved.
+        """
+
+        # Manually download the reference genome since there are difficulties when
+        # streaming the dataset
+        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.coordinate_csv_file = dl_manager.download_and_extract(
+            "cage_prediction/sequences_coordinates.csv"
+        )
+
+        train_file_dict = {}
+        for train_key, train_file in self.generate_npz_filenames(
+                "train", self.NUM_TRAIN, folder="cage_prediction/targets_subset"
+        ):
+            train_file_dict[train_key] = dl_manager.download(train_file)
+
+        test_file_dict = {}
+        for test_key, test_file in self.generate_npz_filenames(
+                "test", self.NUM_TEST, folder="cage_prediction/targets_subset"
+        ):
+            test_file_dict[test_key] = dl_manager.download(test_file)
+
+        valid_file_dict = {}
+        for valid_key, valid_file in self.generate_npz_filenames(
+                "valid", self.NUM_VALID, folder="cage_prediction/targets_subset"
+        ):
+            valid_file_dict[valid_key] = dl_manager.download(valid_file)
+
+        # convert file list to a dict keyed by target number
+        self.target_files_by_split["train"] = train_file_dict
+        self.target_files_by_split["test"] = test_file_dict
+        self.target_files_by_split["validation"] = valid_file_dict
+
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={"handler": self, "split": "train"},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={"handler": self, "split": "validation"},
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={"handler": self, "split": "test"}
+            ),
+        ]
+
+
+    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.
+        """
+
+        target_files = self.target_files_by_split[split]
+        sequence_length = self.sequence_length
+
+        key = 0
+        coordinates_dataframe = pd.read_csv(self.coordinate_csv_file)
+        filtered = coordinates_dataframe[coordinates_dataframe["split"] == split]
+        for sequential_idx, row in filtered.iterrows():
+            start, stop = int(row["start"]) - 1, int(
+                row["stop"]) - 1  # -1 since vcf coords are 1-based
+
+            chromosome = row['chrom']
+            
+            padded_sequence = pad_sequence(
+                chromosome=self.reference_genome[chromosome],
+                start=start,
+                sequence_length=sequence_length,
+                end=stop,
+            )
+
+            # floor npy_idx to the nearest 1000
+            npz_file = np.load(
+                target_files[int((row["npy_idx"] // self.NPZ_SPLIT) * self.NPZ_SPLIT)]
+            )
+
+            if (
+                    split == "validation"
+            ):  # npy files are keyed by ["train", "test", "valid"]
+                split = "valid"
+            targets = npz_file[f"target-{split}-{row['npy_idx']}.npy"][0] # select 0 since there is extra dimension
+            
+            
+            # subset the targets if sequence length is smaller than 114688 (
+            # DEFAULT_LENGTH)
+            if self.sequence_length < self.DEFAULT_LENGTH:
+                idx_diff = (self.DEFAULT_LENGTH - self.sequence_length) // 2 // 128
+                targets = targets[idx_diff:-idx_diff]
+
+            
+            if padded_sequence:
+                yield key, {
+                    "labels": targets,
+                    "sequence": standardize_sequence(padded_sequence),
+                    "chromosome": re.sub("chr","",chromosome)
+                }
+                key += 1
+
+    @staticmethod
+    def generate_npz_filenames(split, total, folder, npz_size=NPZ_SPLIT):
+        """
+        Generates a list of filenames for the npz files stored in the dataset.
+        Yields a tuple of floored multiple of 1000, filename
+        Args:
+            split: split to generate filenames for. Must be in ['train', 'test', 'valid']
+                due to the naming of the files.
+            total: total number of npy targets for given split
+            folder: folder where data is stored.
+            npz_size: number of npy files per npz. Defaults to 1000 because
+                this is the number currently used in the dataset.
+        """
+
+        for i in range(total // npz_size):
+            yield i * npz_size, f"{folder}/targets-{split}-{i * npz_size}-{i * npz_size + (npz_size - 1)}.npz"
+        if total % npz_size != 0:
+            yield (
+                npz_size * (total // npz_size),
+                f"{folder}/targets-{split}-"
+                f"{npz_size * (total // npz_size)}-"
+                f"{npz_size * (total // npz_size) + (total % npz_size - 1)}.npz",
+            )
+
+
+class BulkRnaExpressionHandler(GenomicLRATaskHandler):
+    """
+    Handler for the Bulk RNA Expression task.
+    """
+
+    DEFAULT_LENGTH = 114688
+
+    def __init__(self, sequence_length=DEFAULT_LENGTH, **kwargs):
+        """
+        Creates a new handler for the Bulk RNA Expression Prediction Task.
+        Args:
+            sequence_length: Length of the sequence around the TSS_CAGE start site
+
+        """
+        self.reference_genome = None
+        self.coordinate_csv_file = None
+        self.labels_csv_file = None
+        self.sequence_length = sequence_length
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the Bulk RNA Expression dataset. Each example
+        includes a genomic sequence and a list of label values.
+        """
+        features = datasets.Features(
+            {
+                # DNA sequence
+                "sequence": datasets.Value("string"),
+                # list of expression values in each tissue
+                "labels": datasets.Sequence(datasets.Value("float32")),
+                # chromosome number
+                "chromosome":datasets.Value(dtype="string")
+            }
+        )
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=description,
+            # This defines the different columns of the dataset and their types
+            features=features,
+
+        )
+
+    def split_generators(self, dl_manager, cache_dir_root):
+        """
+        Separates files by split and stores filenames in instance variables.
+        The Bulk RNA 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(
+            H19_REFERENCE_GENOME_URL, cache_dir_root
+        )
+        self.reference_genome = Fasta(reference_genome_file, one_based_attributes=False)
+
+        self.coordinate_csv_file = dl_manager.download_and_extract(
+            "bulk_rna_expression/gene_coordinates.csv"
+        )
+
+        self.labels_csv_file = dl_manager.download_and_extract(
+            "bulk_rna_expression/rna_expression_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.
+        """
+        coordinates_df = pd.read_csv(self.coordinate_csv_file)
+        labels_df = pd.read_csv(self.labels_csv_file)
+
+        coordinates_split_df = coordinates_df[coordinates_df["split"] == split]
+
+        key = 0
+        for idx, coordinates_row in coordinates_split_df.iterrows():
+            start = coordinates_row[
+                        "CAGE_representative_TSS"] - 1  # -1 since vcf coords are 1-based
+
+            chromosome = coordinates_row["chrom"]
+            labels_row = labels_df.loc[idx].values
+            padded_sequence = pad_sequence(
+                chromosome=self.reference_genome[chromosome],
+                start=start,
+                sequence_length=self.sequence_length,
+                negative_strand=coordinates_row["strand"] == "-",
+            )
+            if padded_sequence:
+                yield key, {
+                    "labels": labels_row,
+                    "sequence": standardize_sequence(padded_sequence),
+                    "chromosome":re.sub("chr","",chromosome)
+                }
+                key += 1
+
+
+class VariantEffectPredictionHandler(GenomicLRATaskHandler):
+    """
+    Handler for the Variant Effect Prediction task.
+    """
+
+    DEFAULT_LENGTH = 114688
+
+    def __init__(self, sequence_length=DEFAULT_LENGTH, **kwargs):
+        """
+        Creates a new handler for the Variant Effect Prediction Task.
+        Args:
+            sequence_length: Length of the sequence to pad around the SNP position
+
+        """
+        self.reference_genome = None
+        self.sequence_length = sequence_length
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the Variant Effect Prediction dataset. Each example
+        includes a  genomic sequence with the reference allele as well as the genomic sequence with the alternative allele,
+        and a binary label.
+        """
+        features = datasets.Features(
+            {
+                # DNA sequence
+                "ref_forward_sequence": datasets.Value("string"),
+                "alt_forward_sequence": datasets.Value("string"),
+                # binary label
+                "label": datasets.Value(dtype="int8"),
+                # tissue type
+                "tissue": datasets.Value(dtype="string"),
+                # chromosome number
+                "chromosome": datasets.Value(dtype="string"),
+                # distance to nearest tss
+                "distance_to_nearest_tss":datasets.Value(dtype="int32")
+            }
+        )
+
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=description,
+            # This defines the different columns of the dataset and their types
+            features=features,
+        )
+
+    def split_generators(self, dl_manager, cache_dir_root):
+        """
+        Separates files by split and stores filenames in instance variables.
+        The variant effect prediction dataset requires the reference hg38 genome and
+        coordinates_labels_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.coordinates_labels_csv_file = dl_manager.download_and_extract(
+            f"variant_effect_prediction/All_Tissues.csv"
+        )
+
+        return super().split_generators(dl_manager, cache_dir_root)
+
+    def generate_examples(self, split):
+        """
+        A generator which produces examples each with ref/alt allele
+        and corresponding binary label. The sequences are extended to
+        the desired sequence length and standardized before returning.
+        """
+
+        coordinates_df = pd.read_csv(self.coordinates_labels_csv_file)
+
+        coordinates_split_df = coordinates_df[coordinates_df["split"] == split]
+
+        key = 0
+        for idx, row in coordinates_split_df.iterrows():
+            start = row["POS"] - 1  # sub 1 to create idx since vcf coords are 1-based
+            alt_allele = row["ALT"]
+            label = row["label"]
+            tissue = row['tissue']
+            chromosome = row["CHROM"]
+            distance = int(row["distance_to_nearest_TSS"])
+
+            # get reference forward sequence
+            ref_forward = pad_sequence(
+                chromosome=self.reference_genome[chromosome],
+                start=start,
+                sequence_length=self.sequence_length,
+                negative_strand=False,
+            )
+
+            # only if a valid sequence returned
+            if ref_forward:
+                # Mutate sequence with the alt allele at the SNP position, which is always
+                # centered in the string returned from pad_sequence
+                alt_forward = list(ref_forward)
+                alt_forward[self.sequence_length // 2] = alt_allele
+                alt_forward = "".join(alt_forward)
+
+                yield key, {
+                    "label": label,
+                    "tissue": tissue,
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "ref_forward_sequence": standardize_sequence(ref_forward),
+                    "alt_forward_sequence": standardize_sequence(alt_forward),
+                    "distance_to_nearest_tss": distance
+                }
+                key += 1