paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/cv/transforms/batch_operators.py

@@ -1,286 +0,0 @@
-# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import traceback
-import random
-import numpy as np
-try:
-    from collections.abc import Sequence
-except Exception:
-    from collections import Sequence
-from paddle.fluid.dataloader.collate import default_collate_fn
-from .operators import Transform, Resize, ResizeByShort, _Permute, interp_dict
-from .box_utils import jaccard_overlap
-from paddlex.utils import logging
-
-
-class BatchCompose(Transform):
-    def __init__(self, batch_transforms=None, collate_batch=True):
-        super(BatchCompose, self).__init__()
-        self.batch_transforms = batch_transforms
-        self.collate_batch = collate_batch
-
-    def __call__(self, samples):
-        if self.batch_transforms is not None:
-            for op in self.batch_transforms:
-                try:
-                    samples = op(samples)
-                except Exception as e:
-                    stack_info = traceback.format_exc()
-                    logging.warning("fail to map batch transform [{}] "
-                                    "with error: {} and stack:\n{}".format(
-                                        op, e, str(stack_info)))
-                    raise e
-
-        samples = _Permute()(samples)
-
-        extra_key = ['h', 'w', 'flipped']
-        for k in extra_key:
-            for sample in samples:
-                if k in sample:
-                    sample.pop(k)
-
-        if self.collate_batch:
-            batch_data = default_collate_fn(samples)
-        else:
-            batch_data = {}
-            for k in samples[0].keys():
-                tmp_data = []
-                for i in range(len(samples)):
-                    tmp_data.append(samples[i][k])
-                if not 'gt_' in k and not 'is_crowd' in k and not 'difficult' in k:
-                    tmp_data = np.stack(tmp_data, axis=0)
-                batch_data[k] = tmp_data
-        return batch_data
-
-
-class BatchRandomResize(Transform):
-    """
-    Resize a batch of input to random sizes.
-
-    Attention：If interp is 'RANDOM', the interpolation method will be chose randomly.
-
-    Args:
-        target_sizes (List[int], List[list or tuple] or Tuple[list or tuple]):
-            Multiple target sizes, each target size is an int or list/tuple of length 2.
-        interp ({'NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM'}, optional):
-            Interpolation method of resize. Defaults to 'LINEAR'.
-    Raises:
-        TypeError: Invalid type of target_size.
-        ValueError: Invalid interpolation method.
-
-    See Also:
-        RandomResize: Resize input to random sizes.
-    """
-
-    def __init__(self, target_sizes, interp='NEAREST'):
-        super(BatchRandomResize, self).__init__()
-        if not (interp == "RANDOM" or interp in interp_dict):
-            raise ValueError("interp should be one of {}".format(
-                interp_dict.keys()))
-        self.interp = interp
-        assert isinstance(target_sizes, list), \
-            "target_size must be List"
-        for i, item in enumerate(target_sizes):
-            if isinstance(item, int):
-                target_sizes[i] = (item, item)
-        self.target_size = target_sizes
-
-    def __call__(self, samples):
-        height, width = random.choice(self.target_size)
-        resizer = Resize((height, width), interp=self.interp)
-        samples = resizer(samples)
-
-        return samples
-
-
-class BatchRandomResizeByShort(Transform):
-    """Resize a batch of input to random sizes with keeping the aspect ratio.
-
-    Attention：If interp is 'RANDOM', the interpolation method will be chose randomly.
-
-    Args:
-        short_sizes (List[int], Tuple[int]): Target sizes of the shorter side of the image(s).
-        max_size (int, optional): The upper bound of longer side of the image(s).
-            If max_size is -1, no upper bound is applied. Defaults to -1.
-        interp ({'NEAREST', 'LINEAR', 'CUBIC', 'AREA', 'LANCZOS4', 'RANDOM'}, optional):
-            Interpolation method of resize. Defaults to 'LINEAR'.
-
-    Raises:
-        TypeError: Invalid type of target_size.
-        ValueError: Invalid interpolation method.
-
-    See Also:
-        RandomResizeByShort: Resize input to random sizes with keeping the aspect ratio.
-    """
-
-    def __init__(self, short_sizes, max_size=-1, interp='NEAREST'):
-        super(BatchRandomResizeByShort, self).__init__()
-        if not (interp == "RANDOM" or interp in interp_dict):
-            raise ValueError("interp should be one of {}".format(
-                interp_dict.keys()))
-        self.interp = interp
-        assert isinstance(short_sizes, list), \
-            "short_sizes must be List"
-
-        self.short_sizes = short_sizes
-        self.max_size = max_size
-
-    def __call__(self, samples):
-        short_size = random.choice(self.short_sizes)
-        resizer = ResizeByShort(
-            short_size=short_size, max_size=self.max_size, interp=self.interp)
-
-        samples = resizer(samples)
-
-        return samples
-
-
-class _BatchPadding(Transform):
-    def __init__(self, pad_to_stride=0):
-        super(_BatchPadding, self).__init__()
-        self.pad_to_stride = pad_to_stride
-
-    def __call__(self, samples):
-        coarsest_stride = self.pad_to_stride
-        max_shape = np.array([data['image'].shape for data in samples]).max(
-            axis=0)
-        if coarsest_stride > 0:
-            max_shape[0] = int(
-                np.ceil(max_shape[0] / coarsest_stride) * coarsest_stride)
-            max_shape[1] = int(
-                np.ceil(max_shape[1] / coarsest_stride) * coarsest_stride)
-        for data in samples:
-            im = data['image']
-            im_h, im_w, im_c = im.shape[:]
-            padding_im = np.zeros(
-                (max_shape[0], max_shape[1], im_c), dtype=np.float32)
-            padding_im[:im_h, :im_w, :] = im
-            data['image'] = padding_im
-
-        return samples
-
-
-class _Gt2YoloTarget(Transform):
-    """
-    Generate YOLOv3 targets by groud truth data, this operator is only used in
-    fine grained YOLOv3 loss mode
-    """
-
-    def __init__(self,
-                 anchors,
-                 anchor_masks,
-                 downsample_ratios,
-                 num_classes=80,
-                 iou_thresh=1.):
-        super(_Gt2YoloTarget, self).__init__()
-        self.anchors = anchors
-        self.anchor_masks = anchor_masks
-        self.downsample_ratios = downsample_ratios
-        self.num_classes = num_classes
-        self.iou_thresh = iou_thresh
-
-    def __call__(self, samples, context=None):
-        assert len(self.anchor_masks) == len(self.downsample_ratios), \
-            "anchor_masks', and 'downsample_ratios' should have same length."
-
-        h, w = samples[0]['image'].shape[:2]
-        an_hw = np.array(self.anchors) / np.array([[w, h]])
-        for sample in samples:
-            gt_bbox = sample['gt_bbox']
-            gt_class = sample['gt_class']
-            if 'gt_score' not in sample:
-                sample['gt_score'] = np.ones(
-                    (gt_bbox.shape[0], 1), dtype=np.float32)
-            gt_score = sample['gt_score']
-            for i, (
-                    mask, downsample_ratio
-            ) in enumerate(zip(self.anchor_masks, self.downsample_ratios)):
-                grid_h = int(h / downsample_ratio)
-                grid_w = int(w / downsample_ratio)
-                target = np.zeros(
-                    (len(mask), 6 + self.num_classes, grid_h, grid_w),
-                    dtype=np.float32)
-                for b in range(gt_bbox.shape[0]):
-                    gx, gy, gw, gh = gt_bbox[b, :]
-                    cls = gt_class[b]
-                    score = gt_score[b]
-                    if gw <= 0. or gh <= 0. or score <= 0.:
-                        continue
-
-                    # find best match anchor index
-                    best_iou = 0.
-                    best_idx = -1
-                    for an_idx in range(an_hw.shape[0]):
-                        iou = jaccard_overlap(
-                            [0., 0., gw, gh],
-                            [0., 0., an_hw[an_idx, 0], an_hw[an_idx, 1]])
-                        if iou > best_iou:
-                            best_iou = iou
-                            best_idx = an_idx
-
-                    gi = int(gx * grid_w)
-                    gj = int(gy * grid_h)
-
-                    # gtbox should be regresed in this layes if best match
-                    # anchor index in anchor mask of this layer
-                    if best_idx in mask:
-                        best_n = mask.index(best_idx)
-
-                        # x, y, w, h, scale
-                        target[best_n, 0, gj, gi] = gx * grid_w - gi
-                        target[best_n, 1, gj, gi] = gy * grid_h - gj
-                        target[best_n, 2, gj, gi] = np.log(
-                            gw * w / self.anchors[best_idx][0])
-                        target[best_n, 3, gj, gi] = np.log(
-                            gh * h / self.anchors[best_idx][1])
-                        target[best_n, 4, gj, gi] = 2.0 - gw * gh
-
-                        # objectness record gt_score
-                        target[best_n, 5, gj, gi] = score
-
-                        # classification
-                        target[best_n, 6 + cls, gj, gi] = 1.
-
-                    # For non-matched anchors, calculate the target if the iou
-                    # between anchor and gt is larger than iou_thresh
-                    if self.iou_thresh < 1:
-                        for idx, mask_i in enumerate(mask):
-                            if mask_i == best_idx: continue
-                            iou = jaccard_overlap(
-                                [0., 0., gw, gh],
-                                [0., 0., an_hw[mask_i, 0], an_hw[mask_i, 1]])
-                            if iou > self.iou_thresh and target[idx, 5, gj,
-                                                                gi] == 0.:
-                                # x, y, w, h, scale
-                                target[idx, 0, gj, gi] = gx * grid_w - gi
-                                target[idx, 1, gj, gi] = gy * grid_h - gj
-                                target[idx, 2, gj, gi] = np.log(
-                                    gw * w / self.anchors[mask_i][0])
-                                target[idx, 3, gj, gi] = np.log(
-                                    gh * h / self.anchors[mask_i][1])
-                                target[idx, 4, gj, gi] = 2.0 - gw * gh
-
-                                # objectness record gt_score
-                                target[idx, 5, gj, gi] = score
-
-                                # classification
-                                target[idx, 5 + cls, gj, gi] = 1.
-                sample['target{}'.format(i)] = target
-
-            # remove useless gt_class and gt_score after target calculated
-            sample.pop('gt_class')
-            sample.pop('gt_score')
-
-        return samples

paddlex/cv/transforms/box_utils.py

@@ -1,41 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-
-def bbox_area(src_bbox):
-    if src_bbox[2] < src_bbox[0] or src_bbox[3] < src_bbox[1]:
-        return 0.
-    else:
-        width = src_bbox[2] - src_bbox[0]
-        height = src_bbox[3] - src_bbox[1]
-        return width * height
-
-
-def jaccard_overlap(sample_bbox, object_bbox):
-    if sample_bbox[0] >= object_bbox[2] or \
-            sample_bbox[2] <= object_bbox[0] or \
-            sample_bbox[1] >= object_bbox[3] or \
-            sample_bbox[3] <= object_bbox[1]:
-        return 0
-    intersect_xmin = max(sample_bbox[0], object_bbox[0])
-    intersect_ymin = max(sample_bbox[1], object_bbox[1])
-    intersect_xmax = min(sample_bbox[2], object_bbox[2])
-    intersect_ymax = min(sample_bbox[3], object_bbox[3])
-    intersect_size = (intersect_xmax - intersect_xmin) * (
-        intersect_ymax - intersect_ymin)
-    sample_bbox_size = bbox_area(sample_bbox)
-    object_bbox_size = bbox_area(object_bbox)
-    overlap = intersect_size / (
-        sample_bbox_size + object_bbox_size - intersect_size)
-    return overlap

paddlex/cv/transforms/functions.py

@@ -1,193 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import cv2
-import numpy as np
-
-import shapely.ops
-from shapely.geometry import Polygon, MultiPolygon, GeometryCollection
-import copy
-
-
-def normalize(im, mean, std, min_value=[0, 0, 0], max_value=[255, 255, 255]):
-    # Rescaling (min-max normalization)
-    range_value = np.asarray(
-        [1. / (max_value[i] - min_value[i]) for i in range(len(max_value))],
-        dtype=np.float32)
-    im = (im - np.asarray(min_value, dtype=np.float32)) * range_value
-
-    # Standardization (Z-score Normalization)
-    im -= mean
-    im /= std
-    return im
-
-
-def permute(im, to_bgr=False):
-    im = np.swapaxes(im, 1, 2)
-    im = np.swapaxes(im, 1, 0)
-    if to_bgr:
-        im = im[[2, 1, 0], :, :]
-    return im
-
-
-def center_crop(im, crop_size=224):
-    height, width = im.shape[:2]
-    w_start = (width - crop_size) // 2
-    h_start = (height - crop_size) // 2
-    w_end = w_start + crop_size
-    h_end = h_start + crop_size
-    im = im[h_start:h_end, w_start:w_end, ...]
-    return im
-
-
-def horizontal_flip(im):
-    im = im[:, ::-1, ...]
-    return im
-
-
-def vertical_flip(im):
-    im = im[::-1, :, ...]
-    return im
-
-
-def rgb2bgr(im):
-    return im[:, :, ::-1]
-
-
-def is_poly(poly):
-    assert isinstance(poly, (list, dict)), \
-        "Invalid poly type: {}".format(type(poly))
-    return isinstance(poly, list)
-
-
-def horizontal_flip_poly(poly, width):
-    flipped_poly = np.array(poly)
-    flipped_poly[0::2] = width - np.array(poly[0::2])
-    return flipped_poly.tolist()
-
-
-def horizontal_flip_rle(rle, height, width):
-    import pycocotools.mask as mask_util
-    if 'counts' in rle and type(rle['counts']) == list:
-        rle = mask_util.frPyObjects(rle, height, width)
-    mask = mask_util.decode(rle)
-    mask = mask[:, ::-1]
-    rle = mask_util.encode(np.array(mask, order='F', dtype=np.uint8))
-    return rle
-
-
-def vertical_flip_poly(poly, height):
-    flipped_poly = np.array(poly)
-    flipped_poly[1::2] = height - np.array(poly[1::2])
-    return flipped_poly.tolist()
-
-
-def vertical_flip_rle(rle, height, width):
-    import pycocotools.mask as mask_util
-    if 'counts' in rle and type(rle['counts']) == list:
-        rle = mask_util.frPyObjects(rle, height, width)
-    mask = mask_util.decode(rle)
-    mask = mask[::-1, :]
-    rle = mask_util.encode(np.array(mask, order='F', dtype=np.uint8))
-    return rle
-
-
-def crop_poly(segm, crop):
-    xmin, ymin, xmax, ymax = crop
-    crop_coord = [xmin, ymin, xmin, ymax, xmax, ymax, xmax, ymin]
-    crop_p = np.array(crop_coord).reshape(4, 2)
-    crop_p = Polygon(crop_p)
-
-    crop_segm = list()
-    for poly in segm:
-        poly = np.array(poly).reshape(len(poly) // 2, 2)
-        polygon = Polygon(poly)
-        if not polygon.is_valid:
-            exterior = polygon.exterior
-            multi_lines = exterior.intersection(exterior)
-            polygons = shapely.ops.polygonize(multi_lines)
-            polygon = MultiPolygon(polygons)
-        multi_polygon = list()
-        if isinstance(polygon, MultiPolygon):
-            multi_polygon = copy.deepcopy(polygon)
-        else:
-            multi_polygon.append(copy.deepcopy(polygon))
-        for per_polygon in multi_polygon:
-            inter = per_polygon.intersection(crop_p)
-            if not inter:
-                continue
-            if isinstance(inter, (MultiPolygon, GeometryCollection)):
-                for part in inter:
-                    if not isinstance(part, Polygon):
-                        continue
-                    part = np.squeeze(
-                        np.array(part.exterior.coords[:-1]).reshape(1, -1))
-                    part[0::2] -= xmin
-                    part[1::2] -= ymin
-                    crop_segm.append(part.tolist())
-            elif isinstance(inter, Polygon):
-                crop_poly = np.squeeze(
-                    np.array(inter.exterior.coords[:-1]).reshape(1, -1))
-                crop_poly[0::2] -= xmin
-                crop_poly[1::2] -= ymin
-                crop_segm.append(crop_poly.tolist())
-            else:
-                continue
-    return crop_segm
-
-
-def crop_rle(rle, crop, height, width):
-    import pycocotools.mask as mask_util
-    if 'counts' in rle and type(rle['counts']) == list:
-        rle = mask_util.frPyObjects(rle, height, width)
-    mask = mask_util.decode(rle)
-    mask = mask[crop[1]:crop[3], crop[0]:crop[2]]
-    rle = mask_util.encode(np.array(mask, order='F', dtype=np.uint8))
-    return rle
-
-
-def expand_poly(poly, x, y):
-    expanded_poly = np.array(poly)
-    expanded_poly[0::2] += x
-    expanded_poly[1::2] += y
-    return expanded_poly.tolist()
-
-
-def expand_rle(rle, x, y, height, width, h, w):
-    import pycocotools.mask as mask_util
-    if 'counts' in rle and type(rle['counts']) == list:
-        rle = mask_util.frPyObjects(rle, height, width)
-    mask = mask_util.decode(rle)
-    expanded_mask = np.full((h, w), 0).astype(mask.dtype)
-    expanded_mask[y:y + height, x:x + width] = mask
-    rle = mask_util.encode(np.array(expanded_mask, order='F', dtype=np.uint8))
-    return rle
-
-
-def resize_poly(poly, im_scale_x, im_scale_y):
-    resized_poly = np.array(poly, dtype=np.float32)
-    resized_poly[0::2] *= im_scale_x
-    resized_poly[1::2] *= im_scale_y
-    return resized_poly.tolist()
-
-
-def resize_rle(rle, im_h, im_w, im_scale_x, im_scale_y, interp):
-    import pycocotools.mask as mask_util
-    if 'counts' in rle and type(rle['counts']) == list:
-        rle = mask_util.frPyObjects(rle, im_h, im_w)
-    mask = mask_util.decode(rle)
-    mask = cv2.resize(
-        mask, None, None, fx=im_scale_x, fy=im_scale_y, interpolation=interp)
-    rle = mask_util.encode(np.array(mask, order='F', dtype=np.uint8))
-    return rle