First version of the Custom Anchor Shape dataset.

CustomAnchorShape.py

@@ -0,0 +1,147 @@
+# Hugging Face Loading script
+
+from typing import List, Union
+import numpy as np
+
+import datasets
+from .CustomAnchorShapeGenerator import CustomAnchorShape
+
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {A great new dataset},
+author={huggingface, Inc.
+},
+year={2020}
+}
+"""
+
+# You can copy an official description
+_DESCRIPTION = """\
+This is Custom Anchor shape dataset.
+"""
+
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = ""
+
+# TODO: Add the licence for the dataset here if you can find it
+_LICENSE = ""
+
+
+class CustomAnchorShapeConfig(datasets.BuilderConfig):
+    """Builder Config for CustomShape."""
+
+    def __init__(self, size, custom_data, **kwargs):
+        """BuilderConfig for CustomShape.
+        
+        Args:
+            **kwargs: keyword arguments forwarded to super.
+        """
+        super(CustomAnchorShapeConfig, self).__init__(version=datasets.Version("1.0.0"),**kwargs)
+        self.size = size
+        self.custom_data = custom_data
+
+
+class CustomAnchorShapeDataset(datasets.GeneratorBasedBuilder):
+    """CustomShape dataset."""
+
+    BUILDER_CONFIGS = [
+        CustomAnchorShapeConfig(
+            name='64size',
+            description='64x64 size custom shape dataset.',
+            size=64,
+            custom_data={
+                "train": ['s_curve', 
+                          'swiss_roll', 
+                          [0.5, 0.5], 
+                          [[0.25, 0.25], [0.75, 0.75]],],
+                "validation": ['s_curve', 
+                               'swiss_roll', 
+                               [0.5, 0.5], 
+                               [0.25, 0.25],
+                               [0.25, 0.75],
+                               [0.75, 0.75],
+                               [0.75, 0.25], 
+                               [[0.25, 0.25], [0.75, 0.75]],
+                               [[0.25, 0.75], [0.75, 0.25]],],
+            }
+        ),
+        CustomAnchorShapeConfig(
+            name='224size',
+            description='224x224 size custom shape dataset.',
+            size=224,
+            custom_data={
+                "train": ['s_curve', 
+                          'swiss_roll', 
+                          [0.5, 0.5], 
+                          [[0.25, 0.25], [0.75, 0.75]],],
+                "validation": ['s_curve', 
+                               'swiss_roll', 
+                               [0.5, 0.5], 
+                               [0.25, 0.25],
+                               [0.25, 0.75],
+                               [0.75, 0.75],
+                               [0.75, 0.25], 
+                               [[0.25, 0.25], [0.75, 0.75]],
+                               [[0.25, 0.75], [0.75, 0.25]],],
+            }
+        ),
+    ]
+
+    def _info(self):
+        features = datasets.Features(
+            {
+                'image_id': datasets.Value('int64'),
+                'image': datasets.Image(),
+                'width': datasets.Value('int64'),
+                'height': datasets.Value('int64'),
+                'object': datasets.features.Sequence({
+                    'bbox': datasets.features.Sequence(datasets.Value('float64')),
+                })
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+        )
+
+    def _split_generators(self, dl_manager):
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "width": self.config.size,
+                    "height": self.config.size,
+                    "custom_data": self.config.custom_data['train'],
+                },
+            ),
+        ]
+
+    def _generate_examples(
+            self, 
+            size: Union[int, tuple], 
+            custom_data: List[Union[np.ndarray, str]],
+        ):
+        if isinstance(size, int):
+            width, height = size, size
+        else:
+            width, height = size
+
+        custom_shape = CustomAnchorShape(
+            width, 
+            height, 
+            custom_data=custom_data,
+        )
+        
+        for i, data in enumerate(custom_shape.custom_data):
+            yield {
+                'image_id': i,
+                'image': custom_shape.get_distribution(data, type='img'),
+                'width': width,
+                'height': height,
+                'object': {
+                    'bbox': custom_shape.get_distribution(data, type='1d'),
+                }
+            }

CustomAnchorShapeGenerator.py

@@ -0,0 +1,245 @@
+from typing import List, Union
+from abc import ABC, abstractmethod
+
+import numpy as np
+from PIL import Image
+from sklearn.datasets import make_s_curve, make_swiss_roll
+
+
+class DataExpander(ABC):
+    """Abstract class for data expander with different distribution."""
+        
+    @abstractmethod
+    def expand_data(self, data: np.ndarray, size: int, **kwargs) -> np.ndarray:
+        """Return the expanded data to size."""
+        raise NotImplementedError
+    
+    @abstractmethod
+    def available_data(self, data: np.ndarray, **kwargs) -> np.ndarray:
+        """Return the available data."""
+        raise NotImplementedError
+
+
+class AnchorExpander(DataExpander):
+    """Class for anchor expander with different distribution.
+    
+    Args:
+        expand_type (str): expand type of the anchor distribution. Options include `duplicate` or `uniform` or `gauss`. Default: 'duplicate'.
+    """
+    
+    def __init__(self, expand_type: str = 'duplicate'):
+        self.expand_type = expand_type
+        self.type_map = {
+            'duplicate': self.duplicate,
+            'uniform': self.uniform,
+            'gauss': self.gauss,
+        }
+
+    def _get_anchor_number(self, anchors: np.ndarray):
+        """Return the number of anchors."""
+        assert anchors.ndim == 2 , "anchors should be 2D array."
+        assert anchors.shape[1] == 2 or anchors.shape[1] == 4, "each anchor shaped as (cx, cy) or (cx, cy, w, h)."
+        return anchors.shape[0]
+    
+    def expand_data(self, data: np.ndarray, size: int, **kwargs) -> np.ndarray:
+        """Return the expanded data to size."""
+        anchor_num = self._get_anchor_number(data) + 1
+        expand_space = np.linspace(0, size, anchor_num).astype(int)
+        expand_num = expand_space[1:] - expand_space[:-1]
+        
+        return self.type_map[self.expand_type](data, expand_num)
+    
+    def available_data(self, data: np.ndarray, type=np.float32, **kwargs) -> np.ndarray:
+        """Return the available anchors ranged [0, 1] with type."""
+        data[:, 0::2] = np.clip(data[:, 0::2], 0, 1)
+        data[:, 1::2] = np.clip(data[:, 1::2], 0, 1)
+        if data.dtype != type:
+            data = data.astype(type)
+        return data
+    
+    def duplicate(self, anchors: np.ndarray, expand_num: np.ndarray):
+        """Duplicate each anchor form anchors to expand_num."""
+        return anchors.repeat(expand_num, axis=0)
+        
+    def uniform(self, anchors: np.ndarray, expand_num: np.ndarray):
+        """Uniformly expand each anchor form anchors to expand_num in anchor region."""
+        assert anchors.shape[1] == 4, "Uniformly expand only support anchors shaped as (cx, cy, w, h)."
+        new_anchors = []
+        for n, (cx, cy, w, h) in zip(expand_num, anchors):
+            lt = [cx - w / 2, cy - h / 2]
+            rb = [cx + w / 2, cy + h / 2]
+            new_anchors.append(np.random.uniform(lt, rb, (n, 2)))
+        return np.concatenate(new_anchors, axis=0)
+        
+    def gauss(self, anchors: np.ndarray, expand_num: np.ndarray):
+        """Gaussian expand each anchor form anchors to expand_num in anchor region."""
+        assert anchors.shape[1] == 4, "Gaussian expand only support anchors shaped as (cx, cy, w, h)."
+        new_anchors = []
+        for n, (cx, cy, w, h) in zip(expand_num, anchors):
+            new_anchors.append(np.random.multivariate_normal([cx, cy], [[w, 0], [0, h]], n))
+        return np.concatenate(new_anchors, axis=0)
+
+
+class DataDistributor(ABC):
+    """Abstract class for data distributor."""
+    
+    @abstractmethod
+    def get_distribution(self, data: np.ndarray, **kwargs):
+        """Return the data distribution."""
+        raise NotImplementedError
+
+
+class AnchorDistributor(DataDistributor, AnchorExpander):
+    """Abstract class for anchor distributor.
+    
+    Args:
+        width (int): width of the distribution.
+        height (int): height of the distribution.
+        depth (int): depth of the distribution. Default: 1.
+        expand_type (str): type of the anchor distribution. Options include `duplicate` or `uniform` or `gauss`. Default: 'duplicate'.
+    """
+    
+    def __init__(self, width: int, height: int, depth: int = 1, 
+                 expand_type: str = 'duplicate'):
+        self.width = width
+        self.height = height
+        self.depth = depth
+        AnchorExpander.__init__(self, expand_type)
+    
+    @property
+    def dis_point_num(self):
+        """Return the number of expanded distribution points."""
+        return int(self.width * self.height)
+    
+    def get_distribution(self, data: np.ndarray, type: str = '1d',  **kwargs):
+        """Return the anchor distribution."""
+        if type == '1d':
+            return self.to_1d_distribution(data)
+        elif type == 'img':
+            return self.to_img_distribution(data)
+        else:
+            raise ValueError(f"Unsupported distribute type {type}.")
+    
+    def to_1d_distribution(self, anchors: np.ndarray):
+        """Return the 1D distribution of anchors shaped [NxD, *]."""
+        anchors = np.repeat(anchors, self.depth, axis=0)
+        return anchors
+    
+    def to_img_distribution(self, anchors: np.ndarray) -> Image.Image:
+        """Return the Image filled distribution of anchors."""
+        assert self.depth == 1 or self.depth == 3, "Only support depth 1 (GRAY) or 3(RGB)."
+        img = filled_anchors(anchors, self.width, self.height)
+        gray_img = Image.fromarray(img)
+        if self.depth == 1:
+            return gray_img
+        else:
+            return gray_img.convert('RGB')
+
+
+def filled_anchors(anchors: np.ndarray, width: int, height: int) -> np.ndarray:
+    """Return the hist filled in distributed anchors' c_xy along (x,y) shaped [W, H]."""
+    assert anchors.ndim == 2, "anchors should be 2D array."
+    assert anchors.max() <= 1 and anchors.min() >= 0, "anchors should be ranged [0, 1]."
+    
+    anchor_cxcy = (anchors[:, :2] * np.array([width-1, height-1])).astype(int)
+    anchor_unique, anchor_counts = np.unique(anchor_cxcy, axis=0, return_counts=True)
+    anchor_counts = anchor_counts * 255.0 / anchor_counts.max()
+    anchor_counts = anchor_counts.astype(int).clip(0, 255)
+    anchor_index = anchor_unique[:, 1], anchor_unique[:, 0]
+    hist = np.zeros((width, height), dtype=np.uint8)
+    hist[anchor_index] = anchor_counts
+    return hist
+
+
+class CustomAnchorShape(AnchorDistributor):
+    """Custom anchor shape distributor.
+    
+    Args:
+        width (int): width of the distribution.
+        height (int): height of the distribution.
+        depth (int): depth of the distribution. Default: 1.
+        custom_data (List[Union[np.ndarray, str]]): custom data to be added to the sample. Include `s_curve`, `swiss_roll` and `custom_anchor`.
+        custom_anchor_combination (bool): whether to combine custom anchors.
+        custom_anchor_relative_coord (bool): whether the custom anchor is relative coordinate.
+        expand_type (str): how to expand the anchor. Options include `duplicate` or `uniform` or `gauss`. Default: 'duplicate'.
+    """
+
+    def __init__(self, width: int, height: int, 
+                 depth: int = 1, 
+                 custom_data: List[Union[np.ndarray, str]] = [],
+                 custom_anchor_combination: bool = False,
+                 custom_anchor_relative_coord: bool = True,
+                 expand_type: str = 'duplicate',):
+        AnchorDistributor.__init__(self, width, height, depth, expand_type)
+        self.custom_anchor_combination = custom_anchor_combination
+        self.custom_anchor_relative_coord = custom_anchor_relative_coord
+        self.custom_shapes = [data for data in custom_data if isinstance(data, str)]
+        self.custom_anchors = [data for data in custom_data if isinstance(data, (np.ndarray, list, tuple))]
+        
+    @property
+    def custom_shapes(self):
+        return self._custom_shapes
+    
+    @custom_shapes.setter
+    def custom_shapes(self, value: List[str]):
+        shapes = []
+        for shape in value:
+            assert isinstance(shape, str), "Custom shape must be str."
+            shapes.append(self._get_spical_shape(shape))
+        self._custom_shapes = shapes
+        
+    @property
+    def custom_anchors(self):
+        return self._custom_anchors
+    
+    @custom_anchors.setter
+    def custom_anchors(self, value: List[np.ndarray]):
+        anchors = []
+        for anchor in value:
+            if isinstance(anchor, (list, tuple)):
+                if not isinstance(anchor[0], (list, tuple)):
+                    anchor = [anchor]
+                anchor = np.array(anchor)
+            assert isinstance(anchor, np.ndarray), "Custom anchor must be np.ndarray."
+            anchors.append(anchor)
+        self._custom_anchors = self._get_anchor_combinations(anchors)
+        
+    @property
+    def custom_data(self):
+        return self.custom_shapes + self.custom_anchors
+        
+    def _get_spical_shape(self, shape_name: str, type=np.float32) -> np.ndarray:
+        """Get special shape data shaped [N, 2]. Range [0, 1]"""
+        if shape_name == 's_curve':
+            shape = make_s_curve(self.dis_point_num, noise=0.1)[0]
+            shape = shape[:, [0, 2]]
+        elif shape_name == 'swiss_roll':
+            shape = make_swiss_roll(self.dis_point_num, noise=0.5)[0]
+            shape = shape[:, [0, 2]]
+        else:
+            raise ValueError(f"Not supported shape {shape_name}. Only support 's_curve' or 'swiss_roll'.")
+        shape[:, 0] = (shape[:, 0] - shape[:, 0].min())  / (shape[:, 0].max() - shape[:, 0].min())
+        shape[:, 1] = (shape[:, 1] - shape[:, 1].min()) / (shape[:, 1].max() - shape[:, 1].min())
+        return shape.astype(type)
+    
+    def _pad_custom_anchor(self, anchor:np.ndarray):
+        """Pad custom anchor num to `self.dis_point_num`."""
+        if not self.custom_anchor_relative_coord:
+            anchor = anchor / np.array([self.width, self.height])
+        anchor = self.expand_data(anchor, self.dis_point_num)
+        return self.available_data(anchor)
+    
+    def _get_anchor_combinations(self, anchors: np.ndarray) -> np.ndarray:
+        """Get combinations of anchors shaped [C(N, 1)+...+C(N, N), N, 2]."""
+        comb_anchors = []
+        if self.custom_anchor_combination:
+            from itertools import combinations
+            index = np.arange(len(anchors))
+            for r in index:
+                for comb_i in combinations(index, r+1):
+                    comb = np.concatenate([anchors[i] for i in comb_i], axis=0)
+                    comb_anchors.append(self._pad_custom_anchor(comb))
+        else:
+            for anchor in anchors:
+                comb_anchors.append(self._pad_custom_anchor(anchor))
+        return comb_anchors