testbed/openvinotoolkit__datumaro/datumaro/plugins/splitter.py

# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT

import logging as log
import numpy as np

from datumaro.components.extractor import (Transform, AnnotationType,
    DEFAULT_SUBSET_NAME)

NEAR_ZERO = 1e-7


class _TaskSpecificSplit(Transform):
    def __init__(self, dataset, splits, seed):
        super().__init__(dataset)

        snames, sratio = self._validate_splits(splits)

        self._snames = snames
        self._sratio = sratio

        self._seed = seed

        self._subsets = {"train", "val", "test"}  # output subset names
        self._parts = []
        self._length = "parent"

        self._initialized = False

    def _set_parts(self, by_splits):
        self._parts = []
        for subset in self._subsets:
            self._parts.append((set(by_splits[subset]), subset))

    @staticmethod
    def _get_uniq_annotations(dataset):
        annotations = []
        for item in dataset:
            labels = [a for a in item.annotations
                if a.type == AnnotationType.label]
            if len(labels) != 1:
                raise Exception("Item '%s' contains %s labels, "
                    "but exactly one is expected" % (item.id, len(labels)))
            annotations.append(labels[0])
        return annotations

    @staticmethod
    def _validate_splits(splits, valid=None):
        snames = []
        ratios = []
        if valid is None:
            valid = ["train", "val", "test"]
        for subset, ratio in splits:
            assert subset in valid, \
                "Subset name must be one of %s, but got %s" % (valid, subset)
            assert 0.0 <= ratio and ratio <= 1.0, \
                "Ratio is expected to be in the range " \
                "[0, 1], but got %s for %s" % (ratio, subset)
            snames.append(subset)
            ratios.append(float(ratio))
        ratios = np.array(ratios)

        total_ratio = np.sum(ratios)
        if not abs(total_ratio - 1.0) <= NEAR_ZERO:
            raise Exception(
                "Sum of ratios is expected to be 1, got %s, which is %s"
                % (splits, total_ratio)
            )
        return snames, ratios

    @staticmethod
    def _get_required(ratio):
        min_value = np.max(ratio)
        for i in ratio:
            if NEAR_ZERO < i and i < min_value:
                min_value = i
        required = int(np.around(1.0) / min_value)
        return required

    @staticmethod
    def _get_sections(dataset_size, ratio):
        n_splits = [int(np.around(dataset_size * r)) for r in ratio[:-1]]
        n_splits.append(dataset_size - np.sum(n_splits))

        # if there are splits with zero samples even if ratio is not 0,
        # borrow one from the split who has one or more.
        for ii, num_split in enumerate(n_splits):
            if num_split == 0 and NEAR_ZERO < ratio[ii]:
                midx = np.argmax(n_splits)
                if n_splits[midx] > 0:
                    n_splits[ii] += 1
                    n_splits[midx] -= 1
        sections = np.add.accumulate(n_splits[:-1])
        return sections

    @staticmethod
    def _group_by_attr(items):
        """
        Args:
            items: list of (idx, ann). ann is the annotation from Label object.
        Returns:
            by_attributes: dict of { combination-of-attrs : list of index }
        """
        # group by attributes
        by_attributes = dict()
        for idx, ann in items:
            attributes = tuple(sorted(ann.attributes.items()))
            if attributes not in by_attributes:
                by_attributes[attributes] = []
            by_attributes[attributes].append(idx)
        return by_attributes

    def _split_by_attr(self, datasets, snames, ratio, out_splits,
            dataset_key="label"):
        required = self._get_required(ratio)
        for key, items in datasets.items():
            np.random.shuffle(items)
            by_attributes = self._group_by_attr(items)
            for attributes, indice in by_attributes.items():
                gname = "%s: %s, attrs: %s" % (dataset_key, key, attributes)
                splits = self._split_indice(indice, gname, ratio, required)
                for subset, split in zip(snames, splits):
                    if 0 < len(split):
                        out_splits[subset].extend(split)

    def _split_indice(self, indice, group_name, ratio, required):
        filtered_size = len(indice)
        if filtered_size < required:
            log.warning("Not enough samples for a group, '%s'" % group_name)
        sections = self._get_sections(filtered_size, ratio)
        splits = np.array_split(indice, sections)
        return splits

    def _find_split(self, index):
        for subset_indices, subset in self._parts:
            if index in subset_indices:
                return subset
        return DEFAULT_SUBSET_NAME  # all the possible remainder --> default

    def _split_dataset(self):
        raise NotImplementedError()

    def __iter__(self):
        # lazy splitting
        if self._initialized is False:
            self._split_dataset()
            self._initialized = True
        for i, item in enumerate(self._extractor):
            yield self.wrap_item(item, subset=self._find_split(i))


class ClassificationSplit(_TaskSpecificSplit):
    """
    Splits dataset into train/val/test set in class-wise manner. |n
    |n
    Notes:|n
    - Single label is expected for each DatasetItem.|n
    - If there are not enough images in some class or attributes group,
      the split ratio can't be guaranteed.|n
    """

    def __init__(self, dataset, splits, seed=None):
        """
        Parameters
        ----------
        dataset : Dataset
        splits : list
            A list of (subset(str), ratio(float))
            Subset is expected to be one of ["train", "val", "test"].
            The sum of ratios is expected to be 1.
        seed : int, optional
        """
        super().__init__(dataset, splits, seed)

    def _split_dataset(self):
        np.random.seed(self._seed)

        # support only single label for a DatasetItem
        # 1. group by label
        by_labels = dict()
        annotations = self._get_uniq_annotations(self._extractor)
        for idx, ann in enumerate(annotations):
            label = getattr(ann, 'label', None)
            if label not in by_labels:
                by_labels[label] = []
            by_labels[label].append((idx, ann))

        by_splits = dict()
        for subset in self._subsets:
            by_splits[subset] = []

        # 2. group by attributes
        self._split_by_attr(by_labels, self._snames, self._sratio, by_splits)
        self._set_parts(by_splits)


class MatchingReIDSplit(_TaskSpecificSplit):
    """
    Splits dataset for matching, especially re-id task.|n
    First, splits dataset into 'train+val' and 'test' sets by person id.|n
    Note that this splitting is not by DatasetItem. |n
    Then, tags 'test' into 'gallery'/'query' in class-wise random manner.|n
    Then, splits 'train+val' into 'train'/'val' sets in the same way.|n
    Therefore, the final subsets would be 'train', 'val', 'test'. |n
    And 'gallery', 'query' are tagged using anntoation group.|n
    You can get the 'gallery' and 'query' sets using 'get_subset_by_group'.|n
    Notes:|n
    - Single label is expected for each DatasetItem.|n
    - Each label is expected to have attribute representing the person id. |n
    """

    _group_map = dict()

    def __init__(self, dataset, splits, test_splits, pid_name="PID", seed=None):
        """
        Parameters
        ----------
        dataset : Dataset
        splits : list
            A list of (subset(str), ratio(float))
            Subset is expected to be one of ["train", "val", "test"].
            The sum of ratios is expected to be 1.
        test_splits : list
            A list of (subset(str), ratio(float))
            Subset is expected to be one of ["gallery", "query"].
            The sum of ratios is expected to be 1.
        pid_name: str
            attribute name representing the person id. (default: PID)
        seed : int, optional
        """
        super().__init__(dataset, splits, seed)

        self._test_splits = test_splits
        self._pid_name = pid_name

    def _split_dataset(self):
        np.random.seed(self._seed)

        id_snames, id_ratio = self._snames, self._sratio

        pid_name = self._pid_name
        dataset = self._extractor

        groups = set()

        # group by PID(pid_name)
        by_pid = dict()
        annotations = self._get_uniq_annotations(dataset)
        for idx, ann in enumerate(annotations):
            attributes = dict(ann.attributes.items())
            assert pid_name in attributes, \
                "'%s' is expected as an attribute name" % pid_name
            person_id = attributes[pid_name]
            if person_id not in by_pid:
                by_pid[person_id] = []
            by_pid[person_id].append((idx, ann))
            groups.add(ann.group)

        max_group_id = max(groups)
        self._group_map["gallery"] = max_group_id + 1
        self._group_map["query"] = max_group_id + 2

        required = self._get_required(id_ratio)
        if len(by_pid) < required:
            log.warning("There's not enough IDs, which is %s, "
                "so train/val/test ratio can't be guaranteed."
                % len(by_pid)
            )

        # 1. split dataset into trval and test
        #    IDs in test set should not exist in train/val set.
        test = id_ratio[id_snames.index("test")] if "test" in id_snames else 0
        if NEAR_ZERO < test:  # has testset
            split_ratio = np.array([test, 1.0 - test])
            person_ids = list(by_pid.keys())
            np.random.shuffle(person_ids)
            sections = self._get_sections(len(person_ids), split_ratio)
            splits = np.array_split(person_ids, sections)
            testset = {pid: by_pid[pid] for pid in splits[0]}
            trval = {pid: by_pid[pid] for pid in splits[1]}

            # follow the ratio of datasetitems as possible.
            # naive heuristic: exchange the best item one by one.
            expected_count = int(len(self._extractor) * split_ratio[0])
            testset_total = int(np.sum([len(v) for v in testset.values()]))
            self._rebalancing(testset, trval, expected_count, testset_total)
        else:
            testset = dict()
            trval = by_pid

        by_splits = dict()
        for subset in self._subsets:
            by_splits[subset] = []

        # 2. split 'test' into 'gallery' and 'query'
        if 0 < len(testset):
            for person_id, items in testset.items():
                indice = [idx for idx, _ in items]
                by_splits["test"].extend(indice)

            valid = ["gallery", "query"]
            test_splits = self._test_splits
            test_snames, test_ratio = self._validate_splits(test_splits, valid)
            by_groups = {s: [] for s in test_snames}
            self._split_by_attr(testset, test_snames, test_ratio, by_groups,
                dataset_key=pid_name)

            # tag using group
            for idx, item in enumerate(self._extractor):
                for subset, split in by_groups.items():
                    if idx in split:
                        group_id = self._group_map[subset]
                        item.annotations[0].group = group_id
                        break

        # 3. split 'trval' into  'train' and 'val'
        trval_snames = ["train", "val"]
        trval_ratio = []
        for subset in trval_snames:
            if subset in id_snames:
                val = id_ratio[id_snames.index(subset)]
            else:
                val = 0.0
            trval_ratio.append(val)
        trval_ratio = np.array(trval_ratio)
        total_ratio = np.sum(trval_ratio)
        if total_ratio < NEAR_ZERO:
            trval_splits = list(zip(["train", "val"], trval_ratio))
            log.warning("Sum of ratios is expected to be positive, "
                "got %s, which is %s"
                % (trval_splits, total_ratio)
            )
        else:
            trval_ratio /= total_ratio  # normalize
            self._split_by_attr(trval, trval_snames, trval_ratio, by_splits,
                dataset_key=pid_name)

        self._set_parts(by_splits)

    @staticmethod
    def _rebalancing(test, trval, expected_count, testset_total):
        diffs = dict()
        for id_test, items_test in test.items():
            count_test = len(items_test)
            for id_trval, items_trval in trval.items():
                count_trval = len(items_trval)
                diff = count_trval - count_test
                if diff == 0:
                    continue  # exchange has no effect
                if diff not in diffs:
                    diffs[diff] = [(id_test, id_trval)]
                else:
                    diffs[diff].append((id_test, id_trval))
        exchanges = []
        while True:
            target_diff = expected_count - testset_total
            # find nearest diff.
            keys = np.array(list(diffs.keys()))
            idx = (np.abs(keys - target_diff)).argmin()
            nearest = keys[idx]
            if abs(target_diff) <= abs(target_diff - nearest):
                break
            choice = np.random.choice(range(len(diffs[nearest])))
            pid_test, pid_trval = diffs[nearest][choice]
            testset_total += nearest
            new_diffs = dict()
            for diff, person_ids in diffs.items():
                new_list = []
                for id1, id2 in person_ids:
                    if id1 == pid_test or id2 == pid_trval:
                        continue
                    new_list.append((id1, id2))
                if 0 < len(new_list):
                    new_diffs[diff] = new_list
            diffs = new_diffs
            exchanges.append((pid_test, pid_trval))
        # exchange
        for pid_test, pid_trval in exchanges:
            test[pid_trval] = trval.pop(pid_trval)
            trval[pid_test] = test.pop(pid_test)

    def get_subset_by_group(self, group: str):
        available = list(self._group_map.keys())
        assert group in self._group_map, \
            "Unknown group '%s', available groups: %s" \
            % (group, available)
        group_id = self._group_map[group]
        return self.select(lambda item: item.annotations[0].group == group_id)


class DetectionSplit(_TaskSpecificSplit):
    """
    Splits dataset into train/val/test set for detection task.|n
    For detection dataset, each image can have multiple bbox annotations.|n
    Since one DataItem can't be included in multiple subsets at the same time,
    the dataset can't be divided according to the bbox annotations.|n
    Thus, we split dataset based on DatasetItem
    while preserving label distribution as possible.|n
    |n
    Notes:|n
    - Each DatsetItem is expected to have one or more Bbox annotations.|n
    - Label annotations are ignored. We only focus on the Bbox annotations.|n
    """

    def __init__(self, dataset, splits, seed=None):
        """
        Parameters
        ----------
        dataset : Dataset
        splits : list
            A list of (subset(str), ratio(float))
            Subset is expected to be one of ["train", "val", "test"].
            The sum of ratios is expected to be 1.
        seed : int, optional
        """
        super().__init__(dataset, splits, seed)

    @staticmethod
    def _group_by_bbox_labels(dataset):
        by_labels = dict()
        for idx, item in enumerate(dataset):
            bbox_anns = [a for a in item.annotations
                if a.type == AnnotationType.bbox]
            assert 0 < len(bbox_anns), \
                "Expected more than one bbox annotation in the dataset"
            for ann in bbox_anns:
                label = getattr(ann, 'label', None)
                if label not in by_labels:
                    by_labels[label] = [(idx, ann)]
                else:
                    by_labels[label].append((idx, ann))
        return by_labels

    def _split_dataset(self):
        np.random.seed(self._seed)

        subsets, sratio = self._snames, self._sratio

        # 1. group by bbox label
        by_labels = self._group_by_bbox_labels(self._extractor)

        # 2. group by attributes
        by_combinations = dict()
        for label, items in by_labels.items():
            by_attributes = self._group_by_attr(items)
            for attributes, indice in by_attributes.items():
                gname = "label: %s, attributes: %s" % (label, attributes)
                by_combinations[gname] = indice

        # total number of GT samples per label-attr combinations
        n_combs = {k: len(v) for k, v in by_combinations.items()}

        # 3-1. initially count per-image GT samples
        scores_all = {}
        init_scores = {}
        for idx, _ in enumerate(self._extractor):
            counts = {k: v.count(idx) for k, v in by_combinations.items()}
            scores_all[idx] = counts
            init_scores[idx] = np.sum(
                [v / n_combs[k] for k, v in counts.items()]
            )

        by_splits = dict()
        for sname in self._subsets:
            by_splits[sname] = []

        total = len(self._extractor)
        target_size = dict()
        expected = []  # expected numbers of per split GT samples
        for sname, ratio in zip(subsets, sratio):
            target_size[sname] = total * ratio
            expected.append(
                (sname, {k: v * ratio for k, v in n_combs.items()})
            )

        ##
        # functions for keep the # of annotations not exceed the expected num
        def compute_penalty(counts, n_combs):
            p = 0
            for k, v in counts.items():
                p += max(0, (v / n_combs[k]) - 1.0)
            return p

        def update_nc(counts, n_combs):
            for k, v in counts.items():
                n_combs[k] = max(0, n_combs[k] - v)
                if n_combs[k] == 0:
                    n_combs[k] = -1
            return n_combs

        ##

        # 3-2. assign each DatasetItem to a split, one by one
        for idx, _ in sorted(
            init_scores.items(), key=lambda item: item[1], reverse=True
        ):
            counts = scores_all[idx]

            # shuffling split order to add randomness
            # when two or more splits have the same penalty value
            np.random.shuffle(expected)

            pp = []
            for sname, nc in expected:
                if target_size[sname] <= len(by_splits[sname]):
                    # the split has enough images,
                    # stop adding more images to this split
                    pp.append(1e08)
                else:
                    # compute penalty based on the number of GT samples
                    # added in the split
                    pp.append(compute_penalty(counts, nc))

            # we push an image to a split with the minimum penalty
            midx = np.argmin(pp)

            sname, nc = expected[midx]
            by_splits[sname].append(idx)
            update_nc(counts, nc)

        self._set_parts(by_splits)