src/cl_dataset.py

# coding=utf-8
# Copyright 2020 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Lint as: python3
"""CL_Benchmark Dataset."""

import json
import os
import random
from dataclasses import dataclass, field as dc_field
from typing import Optional
import datasets
from hashlib import md5

logger = datasets.logging.get_logger(__name__)
TASK_CONFIG_FILES = {"train": "train_tasks.json", "dev": "dev_tasks.json", "test": "test_tasks.json"}
INSTRUCTION_STRATEGIES = ['single', 'multiple']
ANSWER_PREFIX = "Output:"
SINGLE_QUOTES_SUBSTITUTE = "#$%#"
AUX_PROB = 0.3


def gen_cache_path(cache_dir, data_args):
    # Handle None: use empty string when data_dir/task_config_dir not provided
    data_dir = data_args.data_dir or ""
    task_config_dir = data_args.task_config_dir or ""
    hash_str = data_dir + task_config_dir + \
               str(data_args.max_num_instances_per_task) + str(data_args.max_num_instances_per_eval_task)
    hash_obj = md5(hash_str.encode("utf-8"))
    hash_id = hash_obj.hexdigest()
    cache_path = os.path.join(cache_dir, str(hash_id))

    return cache_path


def check_path(path):
    if not path or not os.path.exists(path):
        raise ValueError('{} is not valid, please check the input path!'.format(path))


def save_ds(instances, file_name):
    with open(file_name, "w+", encoding='utf-8') as fi:
        json.dump(instances, fi, ensure_ascii=False, indent=2)


@dataclass
class CLConfig(datasets.BuilderConfig):
    """
    Config dataset load procedure.

    Args:
        data_dir: task data dir, which contains the corresponding dataset dirs
        task_config_dir: directory with train/dev/test task config json files
        max_num_instances_per_task: max training sample size of each task
        max_num_instances_per_eval_task: max eval sample size of each task
    """
    task_config_dir: Optional[str] = None
    num_examples: Optional[int] = None
    max_num_instances_per_task: Optional[int] = None
    max_num_instances_per_eval_task: Optional[int] = None
    over_sampling: Optional[bool] = None

    @staticmethod
    def parse_task_config(task_config_dir):
        """Parse train/dev/test task config JSON files from the given directory."""
        if not task_config_dir:
            return None

        task_configs = {}
        for task, file_name in TASK_CONFIG_FILES.items():
            task_config_file = os.path.join(task_config_dir, file_name)

            if not os.path.exists(task_config_file):
                raise ValueError('Please check {} config, {} not exists!'.format(task, task_config_file))

            with open(task_config_file, 'r+') as f:
                task_configs[task] = json.loads(f.read())

        return task_configs


class CLInstructions(datasets.GeneratorBasedBuilder):
    """CL Dataset."""

    VERSION = datasets.Version("2.0.0")
    BUILDER_CONFIG_CLASS = CLConfig
    BUILDER_CONFIGS = [
        CLConfig(name="default", description="Default config for NaturalInstructions")
    ]
    DEFAULT_CONFIG_NAME = "default"

    def _info(self):
        return datasets.DatasetInfo(
            features=datasets.Features(
                {
                    "Task": datasets.Value("string"),
                    "Dataset": datasets.Value("string"),
                    "subset": datasets.Value("string"),
                    "Samples": [{
                        "id": datasets.Value("string"),
                        "sentence": datasets.Value("string"),
                        "label": datasets.Value("string"),
                        "ground_truth": datasets.Value("string")
                    }],
                    "Instance": {
                        "id": datasets.Value("string"),
                        "sentence": datasets.Value("string"),
                        "label": datasets.Value("string"),
                        "instruction": datasets.Value("string"),
                        "ground_truth": datasets.Value("string")
                    }
                }
            ),
            supervised_keys=None
        )


    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        # Parse task configs lazily here (not in CLConfig) because datasets
        # may copy/replace the config object, dropping non-field attributes.
        task_configs = CLConfig.parse_task_config(self.config.task_config_dir)

        if self.config.data_dir is None or task_configs is None:
            logger.error("Please provide right input: data_dir or task_config_dir!")

        split_dir = self.config.data_dir

        return [
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                gen_kwargs={
                    "path": split_dir,
                    "task_config": task_configs['train'],
                    "max_num_instances_per_task": self.config.max_num_instances_per_task,
                    "subset": "train"
                }),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                gen_kwargs={
                    "path": split_dir,
                    "task_config": task_configs['dev'],
                    "max_num_instances_per_task": self.config.max_num_instances_per_eval_task,
                    "subset": "dev"
                }),
            datasets.SplitGenerator(
                name=datasets.Split.TEST,
                gen_kwargs={
                    "path": split_dir,
                    "task_config": task_configs['test'],
                    "max_num_instances_per_task": None,  # default load total test samples to test
                    "subset": "test"
                }),
        ]


    def _load_dataset(self, dataset_path):
        with open(dataset_path, encoding="utf-8") as task_f:
            s = task_f.read()
            instances = json.loads(s)
        
        return instances
    
    def load_LongSeq_dataset(self, dataset_path, labels_path, dataset_name, sampling_strategy, max_num_instances, subset):

        data = self._load_dataset(dataset_path)
        print(list(data.keys()))
        input_mode='zeroshot'
        definition = ""
        if len(data["Definition"]) > 0:
            if input_mode=='fewshot' or input_mode=='zeroshot':
                if isinstance(data["Definition"], list):
                    definition = data["Definition"][0].strip() # TODO: should we use <Definition>?
                else:
                    definition = data["Definition"].strip()
                definition += "\n"

        sample_template = {"Task": "CL", "Dataset": dataset_name, "Samples": [], "subset": subset}

        for idx, instance in enumerate(data['Instances']):
            example = sample_template.copy()
            instruction = ""
            # add the input first.
            instruction += "{0}"
            instruction += "\n"
            instruction += "Output: "
            pos_examples = []
            if input_mode=='fewshot':
                for idx, pos_example in enumerate(data["Positive Examples"][:1]):
                    pos_example_str = f"Positive Example {idx+1} -\n"
                    pos_example_str += f"Input: {pos_example['input'].strip()}"
                    pos_example_str += "\n"
                    pos_example_str += f"Output: {pos_example['output'].strip()}"
                    pos_example_str += "\n" 
                    pos_examples.append(pos_example_str)

            instruction = definition + "".join(pos_examples) + instruction

            # print('-------------------')
            # print(instruction)
            # print('-------------------')

            if isinstance(instance["output"], list):
                label=instance["output"][random.randint(0, len(instance["output"])-1)]
            else:
                label=instance["output"]

            example["Instance"] = {
                "id": str(idx),
                "sentence": instance['input'],
                "label": label,
                "ground_truth": label,
                "instruction": instruction
            }

            yield example

    def load_SuperNI_dataset(self, dataset_path, labels_path, dataset_name, sampling_strategy, max_num_instances, subset):

        data = self._load_dataset(dataset_path)
        print(list(data.keys()))
        input_mode='zeroshot'
        definition = ""
        if input_mode=='fewshot' or input_mode=='zeroshot':
            if isinstance(data["Definition"], list):
                definition = "Definition: " + data["Definition"][0].strip() # TODO: should we use <Definition>?
            else:
                definition = "Definition: " + data["Definition"].strip()
            definition += "\n\n"

        sample_template = {"Task": "CL", "Dataset": dataset_name, "Samples": [], "subset": subset}

        for idx, instance in enumerate(data['Instances']):
            example = sample_template.copy()
            instruction = ""
            # add the input first.
            if input_mode=='fewshot' or input_mode=='zeroshot':
                instruction += "Now complete the following example -\n"
            instruction += "Input: {0}"
            instruction += "\n"
            instruction += "Output: "
            pos_examples = []
            if input_mode=='fewshot':
                for idx, pos_example in enumerate(data["Positive Examples"][:1]):
                    pos_example_str = f"Positive Example {idx+1} -\n"
                    pos_example_str += f"Input: {pos_example['input'].strip()}"
                    pos_example_str += "\n"
                    pos_example_str += f"Output: {pos_example['output'].strip()}"
                    pos_example_str += "\n" 
                    pos_examples.append(pos_example_str)

            instruction = definition + "".join(pos_examples) + instruction

            # print('-------------------')
            # print(instruction)
            # print('-------------------')

            if isinstance(instance["output"], list):
                label=instance["output"][random.randint(0, len(instance["output"])-1)]
            else:
                label=instance["output"]

            example["Instance"] = {
                "id": str(idx),
                "sentence": instance['input'],
                "label": label,
                "ground_truth": label,
                "instruction": instruction
            }

            yield example


    def _generate_examples(self, path=None, task_config=None, max_num_instances_per_task=None, subset=None):
        """Yields examples."""
        logger.info(f"Generating tasks from = {path}")

        for task in task_config:
            if task == 'SuperNI':
                load_func = self.load_SuperNI_dataset
            elif task == "Long_Sequence":
                load_func = self.load_LongSeq_dataset
            elif task == "Unseen":
                load_func = self.load_SuperNI_dataset
            else:
                raise ValueError("Unsupport {} task, plz check {} task config!".format(task, subset))

            # load dataset
            for dataset in task_config[task]:
                ds_name = dataset["dataset name"]
                sampling_strategy = dataset.get("sampling strategy", "random")
                ds_path = os.path.join(path, task, ds_name, subset + '.json')
                print(ds_path)
                labels_path = None
                assert os.path.exists(ds_path)

                idx = -1
                instances = []
                for sample in load_func(ds_path, labels_path, ds_name, sampling_strategy, max_num_instances_per_task,
                                        subset):
                    idx += 1
                    instances.append(sample)
                    yield f"{task}##{ds_path}##{idx}", sample