agro-nt-tasks.py

# See the License for the specific language governing permissions and
# limitations under the License.
# TODO: Address all TODOs and remove all explanatory comments
"""TODO: Add a description here."""


import csv
import json
import os
from typing import List
from Bio import SeqIO

import datasets


# TODO: Add BibTeX citation
_CITATION = ''
# """\
# @InProceedings{huggingface:dataset,
# title = {A great new dataset},
# author={huggingface, Inc.
# },
# year={2020}
# }
# """

_DESCRIPTION = """\
This dataset comprises the various supervised learning tasks considered in the agro-nt 
paper. The task types include binary classification,multi-label classification, 
regression,and multi-output regression. The actual underlying genomic tasks range from 
predicting regulatory features, RNA processing sites, and gene expression values.
"""


# TODO: Add the licence for the dataset here if you can find it
_LICENSE = ""

_TASK_NAMES =  ['poly_a.arabidopsis_thaliana',
                'poly_a.oryza_sativa_indica_group',
                'poly_a.trifolium_pratense',
                'poly_a.medicago_truncatula',
                'poly_a.chlamydomonas_reinhardtii',
                'poly_a.oryza_sativa_japonica_group',
                'splicing.arabidopsis_thaliana_donor',
                'splicing.arabidopsis_thaliana_acceptor',
                'lncrna.m_esculenta',
                'lncrna.z_mays',
                'lncrna.g_max',
                'lncrna.s_lycopersicum',
                'lncrna.t_aestivum',
                'lncrna.s_bicolor',
                'promoter_strength.leaf',
                'promoter_strength.protoplast',
                'gene_exp.glycine_max',
                'gene_exp.oryza_sativa',
                'gene_exp.solanum_lycopersicum',
                'gene_exp.zea_mays',
                'gene_exp.arabidopsis_thaliana'
                ]


_TASK_INFO = {'poly_a':{'type': 'binary', 'val_set':False},
              'splicing':{'type': 'binary', 'val_set':False},
              'lncrna':{'type': 'binary', 'val_set':False},
              'promoter_strength': {'type': 'regression', 'val_set': True},
              'gene_exp':{'type':'multi_regression','val_set':True,
                        'num_labels':
                        {'arabidopsis_thaliana': 56,
                        'glycine_max': 14,
                        'zea_mays': 23,
                        'solanum_lycopersicum': 10,
                        'oryza_sativa': 7}},
              }

class AgroNtTasksConfig(datasets.BuilderConfig):
    """BuilderConfig for the Agro NT supervised learning tasks dataset."""

    def __init__(self, *args, task_name: str, **kwargs):
        """BuilderConfig downstream tasks dataset.
        Args:
            task (:obj:`str`): Task name.
            **kwargs: keyword arguments forwarded to super.
        """

        self.task,self.sub_task = task_name.split(".")

        self.task_type = _TASK_INFO[self.task]['type']
        self.val_set = _TASK_INFO[self.task]['val_set']

        super().__init__(
            *args,
            name=f"{task_name}",
            **kwargs,
        )


class AgroNtTasks(datasets.GeneratorBasedBuilder):
    """GeneratorBasedBuilder for the Agro NT supervised learning tasks dataset."""

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

    BUILDER_CONFIGS = [AgroNtTasksConfig(task_name=TASK_NAME) for TASK_NAME
                       in _TASK_NAMES]

    def _info(self):

        if self.config.task_type == 'binary':
            features = datasets.Features(
                {
                    "sequence": datasets.Value("string"),
                    "name": datasets.Value("string"),
                    "label": datasets.Value("int8"),
                }
            )
        elif self.config.task_type == 'regression':
            features = datasets.Features(
                {
                    "sequence": datasets.Value("string"),
                    "name": datasets.Value("string"),
                    "label": datasets.Value("float32"),
                }
            )

        elif self.config.task_type == 'multi_regression':

            num_labels = _TASK_INFO[self.config.task]['num_labels'][self.config.sub_task]

            features = datasets.Features({
                    "sequence": datasets.Value("string"),
                    "name": datasets.Value("string"),
                    "label": datasets.Array2D(shape=(1, num_labels),
                                              dtype= "float32")})

        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,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager) -> List[datasets.SplitGenerator]:

        train_file = dl_manager.download_and_extract(
            os.path.join(self.config.task, self.config.sub_task + "_train.fa"))
        test_file = dl_manager.download_and_extract(
            os.path.join(self.config.task, self.config.sub_task + "_test.fa"))

        generator_list = [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": train_file,
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": test_file,
                },
            ),
        ]

        if self.config.val_set:
            validation_file = dl_manager.download_and_extract(
                os.path.join(self.config.task, self.config.sub_task + "_validation.fa"))

            generator_list += datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "filepath": validation_file,
                },
            ),

        return generator_list

    # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
    def _generate_examples(self, filepath):
        with open(filepath, 'r') as f:
            key = 0
            for record in SeqIO.parse(f,'fasta'):
                # Yields examples as (key, example) tuples

                split_name = record.name.split("|")
                name = split_name[0]
                labels = split_name[1]

                yield key, {
                    "sequence": str(record.seq),
                    "name": name,
                    "label": labels,
                }
                key += 1