update main loader script for new datasets

genomics-long-range-benchmark.py

@@ -14,14 +14,12 @@ 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"
@@ -31,9 +29,9 @@ H19_REFERENCE_GENOME_URL = (
 )
 
 """
---------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 Task Specific Handlers:
--------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 """
 
 class GenomicLRATaskHandler(ABC):
@@ -97,8 +95,8 @@ class GenomicLRATaskHandler(ABC):
 
     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.
+        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.
@@ -138,29 +136,30 @@ class CagePredictionHandler(GenomicLRATaskHandler):
         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
+    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.
+            sequence_length: allows for increasing sequence context. Sequence length
+            must be an even 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."
+            f"Requested sequence length must be an even multuple of 128 to align "
+            f"with the binned labels."
         )
 
         self.sequence_length = sequence_length
 
         if self.sequence_length < self.DEFAULT_LENGTH:
-
-            self.TARGET_SHAPE = (self.sequence_length//128,50)
-    
+            self.TARGET_SHAPE = (self.sequence_length // 128, 50)
 
     def get_info(self, description: str) -> DatasetInfo:
         """
@@ -174,7 +173,11 @@ class CagePredictionHandler(GenomicLRATaskHandler):
                 # array of sequence length x num_labels
                 "labels": datasets.Array2D(shape=self.TARGET_SHAPE, dtype="float32"),
                 # chromosome number
-                "chromosome":datasets.Value(dtype="string")
+                "chromosome": datasets.Value(dtype="string"),
+                # start
+                "start": datasets.Value(dtype="int32"),
+                # stop
+                "stop": datasets.Value(dtype="int32")
             }
         )
         return datasets.DatasetInfo(
@@ -192,31 +195,31 @@ class CagePredictionHandler(GenomicLRATaskHandler):
         """
 
         # Manually download the reference genome since there are difficulties when
-        # streaming the dataset
+        # 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.coordinate_csv_file = dl_manager.download_and_extract(
-            "cage_prediction/sequences_coordinates.csv"
+            "cage_expression/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", self.NUM_TRAIN, folder="cage_expression/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", self.NUM_TEST, folder="cage_expression/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", self.NUM_VALID, folder="cage_expression/targets_subset"
         ):
             valid_file_dict[valid_key] = dl_manager.download(valid_file)
 
@@ -225,7 +228,6 @@ class CagePredictionHandler(GenomicLRATaskHandler):
         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,
@@ -241,7 +243,6 @@ class CagePredictionHandler(GenomicLRATaskHandler):
             ),
         ]
 
-
     def generate_examples(self, split):
         """
         A generator which produces examples for the given split, each with a sequence
@@ -257,10 +258,10 @@ class CagePredictionHandler(GenomicLRATaskHandler):
         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
+                row["stop"]) - 1  # -1 since coords are 1-based
 
             chromosome = row['chrom']
-            
+
             padded_sequence = pad_sequence(
                 chromosome=self.reference_genome[chromosome],
                 start=start,
@@ -277,21 +278,22 @@ class CagePredictionHandler(GenomicLRATaskHandler):
                     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
-            
-            
+            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)
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "start": int(row["start"]),
+                    "stop": int(row["stop"])
                 }
                 key += 1
 
@@ -325,7 +327,7 @@ class BulkRnaExpressionHandler(GenomicLRATaskHandler):
     Handler for the Bulk RNA Expression task.
     """
 
-    DEFAULT_LENGTH = 114688
+    DEFAULT_LENGTH = 100000
 
     def __init__(self, sequence_length=DEFAULT_LENGTH, **kwargs):
         """
@@ -351,7 +353,9 @@ class BulkRnaExpressionHandler(GenomicLRATaskHandler):
                 # list of expression values in each tissue
                 "labels": datasets.Sequence(datasets.Value("float32")),
                 # chromosome number
-                "chromosome":datasets.Value(dtype="string")
+                "chromosome": datasets.Value(dtype="string"),
+                # position
+                "position": datasets.Value(dtype="int32"),
             }
         )
         return datasets.DatasetInfo(
@@ -368,7 +372,7 @@ class BulkRnaExpressionHandler(GenomicLRATaskHandler):
         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
         )
@@ -398,7 +402,7 @@ class BulkRnaExpressionHandler(GenomicLRATaskHandler):
         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
+                        "CAGE_representative_TSS"] - 1  # -1 since coords are 1-based
 
             chromosome = coordinates_row["chrom"]
             labels_row = labels_df.loc[idx].values
@@ -412,21 +416,22 @@ class BulkRnaExpressionHandler(GenomicLRATaskHandler):
                 yield key, {
                     "labels": labels_row,
                     "sequence": standardize_sequence(padded_sequence),
-                    "chromosome":re.sub("chr","",chromosome)
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "position": coordinates_row["CAGE_representative_TSS"]
                 }
                 key += 1
 
 
-class VariantEffectPredictionHandler(GenomicLRATaskHandler):
+class VariantEffectCausalEqtl(GenomicLRATaskHandler):
     """
-    Handler for the Variant Effect Prediction task.
+    Handler for the Variant Effect Causal eQTL task.
     """
 
-    DEFAULT_LENGTH = 114688
+    DEFAULT_LENGTH = 100000
 
     def __init__(self, sequence_length=DEFAULT_LENGTH, **kwargs):
         """
-        Creates a new handler for the Variant Effect Prediction Task.
+        Creates a new handler for the Variant Effect Causal eQTL Task.
         Args:
             sequence_length: Length of the sequence to pad around the SNP position
 
@@ -436,9 +441,9 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
 
     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.
+        Returns the DatasetInfo for the Variant Effect Causal eQTL 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(
             {
@@ -451,8 +456,10 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
                 "tissue": datasets.Value(dtype="string"),
                 # chromosome number
                 "chromosome": datasets.Value(dtype="string"),
+                # variant position
+                "position": datasets.Value(dtype="int32"),
                 # distance to nearest tss
-                "distance_to_nearest_tss":datasets.Value(dtype="int32")
+                "distance_to_nearest_tss": datasets.Value(dtype="int32")
             }
         )
 
@@ -478,7 +485,7 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
 
         self.reference_genome = Fasta(reference_genome_file, one_based_attributes=False)
         self.coordinates_labels_csv_file = dl_manager.download_and_extract(
-            f"variant_effect_gene_expression/All_Tissues.csv"
+            f"variant_effect_prediction/All_Tissues.csv"
         )
 
         return super().split_generators(dl_manager, cache_dir_root)
@@ -496,7 +503,7 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
 
         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
+            start = row["POS"] - 1  # sub 1 to create idx since coords are 1-based
             alt_allele = row["ALT"]
             label = row["label"]
             tissue = row['tissue']
@@ -513,8 +520,8 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
 
             # 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
+                # 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)
@@ -525,14 +532,351 @@ class VariantEffectPredictionHandler(GenomicLRATaskHandler):
                     "chromosome": re.sub("chr", "", chromosome),
                     "ref_forward_sequence": standardize_sequence(ref_forward),
                     "alt_forward_sequence": standardize_sequence(alt_forward),
-                    "distance_to_nearest_tss": distance
+                    "distance_to_nearest_tss": distance,
+                    "position": row["POS"]
+                }
+                key += 1
+
+
+class VariantEffectPathogenicHandler(GenomicLRATaskHandler):
+    """
+    Handler for the Variant Effect Pathogenic Prediction tasks.
+    """
+
+    DEFAULT_LENGTH = 100000
+
+    def __init__(self, sequence_length=DEFAULT_LENGTH, task_name=None, subset=False,
+                 **kwargs):
+        """
+        Creates a new handler for the Variant Effect Pathogenic Tasks.
+        Args:
+            sequence_length: Length of the sequence to pad around the SNP position
+            subset: Whether to return a pre-determined subset of the data.
+
+        """
+        self.sequence_length = sequence_length
+
+        if task_name == 'variant_effect_pathogenic_coding':
+            self.data_file_name = "variant_effect_pathogenic/vep_pathogenic_coding.csv"
+        elif task_name == 'variant_effect_pathogenic_non_coding':
+            self.data_file_name = "variant_effect_pathogenic/" \
+                                  "vep_pathogenic_non_coding_subset.csv" \
+                if subset else "variant_effect_pathogenic/vep_pathogenic_non_coding.csv"
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the Variant Effect Pathogenic datasets. 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"),
+                # chromosome number
+                "chromosome": datasets.Value(dtype="string"),
+                # position
+                "position": 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 datasets require the reference hg38 genome and
+        coordinates_labels_csv_file to be saved.
+        """
+
+        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(
+            self.data_file_name)
+
+        if 'non_coding' in self.data_file_name:
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TEST,
+                    gen_kwargs={"handler": self, "split": "test"}
+                ), ]
+        else:
+            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 coords are 1-based
+            alt_allele = row["ALT"]
+            label = row["INT_LABEL"]
+            chromosome = row["CHROM"]
+
+            # 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,
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "ref_forward_sequence": standardize_sequence(ref_forward),
+                    "alt_forward_sequence": standardize_sequence(alt_forward),
+                    "position": row['POS']
                 }
                 key += 1
 
+
+class ChromatinFeaturesHandler(GenomicLRATaskHandler):
+    """
+    Handler for the histone marks and DNA accessibility tasks also referred to
+    collectively as Chromatin features.
+    """
+
+    DEFAULT_LENGTH = 100000
+
+    def __init__(self, task_name=None, sequence_length=DEFAULT_LENGTH, subset=False,
+                 **kwargs):
+        """
+        Creates a new handler for the Deep Sea Histone and DNase tasks.
+        Args:
+            sequence_length: Length of the sequence around and including the
+            annotated 200bp bin
+            subset: Whether to return a pre-determined subset of the entire dataset.
+
+        """
+        self.sequence_length = sequence_length
+
+        if sequence_length < 200:
+            raise ValueError(
+                'Sequence length for this task must be greater or equal to 200 bp')
+
+        if 'histone' in task_name:
+            self.label_name = 'HISTONES'
+        elif 'dnase' in task_name:
+            self.label_name = 'DNASE'
+
+        self.data_file_name = "chromatin_features/histones_and_dnase_subset.csv" if \
+            subset else "chromatin_features/histones_and_dnase.csv"
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the histone marks and dna accessibility datasets.
+        Each example includes a genomic sequence and a list of label values.
+        """
+        features = datasets.Features(
+            {
+                # DNA sequence
+                "sequence": datasets.Value("string"),
+                # list of binary chromatin marks
+                "labels": datasets.Sequence(datasets.Value("int8")),
+                # chromosome number
+                "chromosome": datasets.Value(dtype="string"),
+                # position
+                "position": 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 histone marks and dna accessibility datasets require the reference hg19
+        genome and coordinate csv file to be saved.
+        """
+        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(self.data_file_name)
+
+        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)
+        coordinates_split_df = coordinates_df[coordinates_df["split"] == split]
+
+        key = 0
+        for idx, coordinates_row in coordinates_split_df.iterrows():
+            start = coordinates_row['POS'] - 1  # -1 since saved coords are 1-based
+            chromosome = coordinates_row["CHROM"]
+
+            # literal eval used since lists are saved as strings in csv
+            labels_row = literal_eval(coordinates_row[self.label_name])
+
+            padded_sequence = pad_sequence(
+                chromosome=self.reference_genome[chromosome],
+                start=start,
+                sequence_length=self.sequence_length,
+            )
+            if padded_sequence:
+                yield key, {
+                    "labels": labels_row,
+                    "sequence": standardize_sequence(padded_sequence),
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "position": coordinates_row['POS']
+                }
+                key += 1
+
+
+class RegulatoryElementHandler(GenomicLRATaskHandler):
+    """
+    Handler for the Regulatory Element Prediction tasks.
+    """
+    DEFAULT_LENGTH = 100000
+
+    def __init__(self, task_name=None, sequence_length=DEFAULT_LENGTH, subset=False,
+                 **kwargs):
+        """
+        Creates a new handler for the Regulatory Element Prediction tasks.
+        Args:
+            sequence_length: Length of the sequence around the element/non-element
+            subset: Whether to return a pre-determined subset of the entire dataset.
+
+        """
+
+        if sequence_length < 200:
+            raise ValueError(
+                'Sequence length for this task must be greater or equal to 200 bp')
+
+        self.sequence_length = sequence_length
+
+        if 'promoter' in task_name:
+            self.data_file_name = 'regulatory_elements/promoter_dataset'
+
+        elif 'enhancer' in task_name:
+            self.data_file_name = 'regulatory_elements/enhancer_dataset'
+
+        if subset:
+            self.data_file_name += '_subset.csv'
+        else:
+            self.data_file_name += '.csv'
+
+    def get_info(self, description: str) -> DatasetInfo:
+        """
+        Returns the DatasetInfo for the Regulatory Element Prediction Tasks.
+        Each example includes a genomic sequence and a label.
+        """
+        features = datasets.Features(
+            {
+                # DNA sequence
+                "sequence": datasets.Value("string"),
+                # label corresponding to whether the sequence has
+                # the regulatory element of interest or not
+                "labels": datasets.Value("int8"),
+                # chromosome number
+                "chromosome": datasets.Value(dtype="string"),
+                # start
+                "start": datasets.Value(dtype="int32"),
+                # stop
+                "stop": 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.
+        """
+        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(
+            self.data_file_name
+        )
+
+        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 label. The sequences are padded to the correct sequence
+        length and standardized before returning.
+        """
+        coordinates_df = pd.read_csv(self.coordinate_csv_file)
+
+        coordinates_split_df = coordinates_df[coordinates_df["split"] == split]
+
+        key = 0
+        for _, coordinates_row in coordinates_split_df.iterrows():
+            start = coordinates_row["START"] - 1  # -1 since vcf coords are 1-based
+            end = coordinates_row["STOP"] - 1  # -1 since vcf coords are 1-based
+            chromosome = coordinates_row["CHROM"]
+
+            label = coordinates_row['label']
+
+            padded_sequence = pad_sequence(
+                chromosome=self.reference_genome[chromosome],
+                start=start,
+                end=end,
+                sequence_length=self.sequence_length,
+            )
+
+            if padded_sequence:
+                yield key, {
+                    "labels": label,
+                    "sequence": standardize_sequence(padded_sequence),
+                    "chromosome": re.sub("chr", "", chromosome),
+                    "start": coordinates_row["START"],
+                    "stop": coordinates_row["STOP"]
+                }
+                key += 1
+
+
 """
---------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 Dataset loader:
--------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 """
 
 _DESCRIPTION = """
@@ -542,7 +886,13 @@ Dataset for benchmark of genomic deep learning models.
 _TASK_HANDLERS = {
     "cage_prediction": CagePredictionHandler,
     "bulk_rna_expression": BulkRnaExpressionHandler,
-    "variant_effect_gene_expression": VariantEffectPredictionHandler,
+    "variant_effect_causal_eqtl": VariantEffectCausalEqtl,
+    "variant_effect_pathogenic_clinvar": VariantEffectPathogenicHandler,
+    "variant_effect_pathogenic_omim": VariantEffectPathogenicHandler,
+    "chromatin_features_histone_marks": ChromatinFeaturesHandler,
+    "chromatin_features_dna_accessibility": ChromatinFeaturesHandler,
+    "regulatory_element_promoter": RegulatoryElementHandler,
+    "regulatory_element_enhancer": RegulatoryElementHandler,
 }
 
 
@@ -558,7 +908,7 @@ class GenomicsLRAConfig(datasets.BuilderConfig):
             **kwargs: keyword arguments forwarded to super.
         """
         super().__init__()
-        self.handler = _TASK_HANDLERS[task_name](task_name=task_name,**kwargs)
+        self.handler = _TASK_HANDLERS[task_name](task_name=task_name, **kwargs)
 
 
 # DatasetBuilder
@@ -592,9 +942,9 @@ class GenomicsLRATasks(datasets.GeneratorBasedBuilder):
 
 
 """
---------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 Global Utils:
--------------------------------------------------------------------------------------------
+----------------------------------------------------------------------------------------
 """
 
 
@@ -625,7 +975,8 @@ def pad_sequence(chromosome, start, sequence_length, end=None, negative_strand=F
             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
+        negative_strand: If negative_strand, returns the reverse compliment of the
+        sequence
     """
     if end:
         pad = (sequence_length - (end - start)) // 2