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

paddlex/ppcls/data/imaug/grid.py

@@ -1,89 +0,0 @@
-# Copyright (c) 2020 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.
-
-# This code is based on https://github.com/akuxcw/GridMask
-
-import numpy as np
-from PIL import Image
-import pdb
-
-# curr
-CURR_EPOCH = 0
-# epoch for the prob to be the upper limit
-NUM_EPOCHS = 240
-
-
-class GridMask(object):
-    def __init__(self, d1=96, d2=224, rotate=1, ratio=0.5, mode=0, prob=1.):
-        self.d1 = d1
-        self.d2 = d2
-        self.rotate = rotate
-        self.ratio = ratio
-        self.mode = mode
-        self.st_prob = prob
-        self.prob = prob
-        self.last_prob = -1
-
-    def set_prob(self):
-        global CURR_EPOCH
-        global NUM_EPOCHS
-        self.prob = self.st_prob * min(1, 1.0 * CURR_EPOCH / NUM_EPOCHS)
-
-    def __call__(self, img):
-        self.set_prob()
-        if abs(self.last_prob - self.prob) > 1e-10:
-            global CURR_EPOCH
-            global NUM_EPOCHS
-            print(
-                "self.prob is updated, self.prob={}, CURR_EPOCH: {}, NUM_EPOCHS: {}".
-                format(self.prob, CURR_EPOCH, NUM_EPOCHS))
-            self.last_prob = self.prob
-        # print("CURR_EPOCH: {}, NUM_EPOCHS: {}, self.prob is set as: {}".format(CURR_EPOCH, NUM_EPOCHS, self.prob) )
-        if np.random.rand() > self.prob:
-            return img
-        _, h, w = img.shape
-        hh = int(1.5 * h)
-        ww = int(1.5 * w)
-        d = np.random.randint(self.d1, self.d2)
-        #d = self.d
-        self.l = int(d * self.ratio + 0.5)
-        mask = np.ones((hh, ww), np.float32)
-        st_h = np.random.randint(d)
-        st_w = np.random.randint(d)
-        for i in range(-1, hh // d + 1):
-            s = d * i + st_h
-            t = s + self.l
-            s = max(min(s, hh), 0)
-            t = max(min(t, hh), 0)
-            mask[s:t, :] *= 0
-        for i in range(-1, ww // d + 1):
-            s = d * i + st_w
-            t = s + self.l
-            s = max(min(s, ww), 0)
-            t = max(min(t, ww), 0)
-            mask[:, s:t] *= 0
-        r = np.random.randint(self.rotate)
-        mask = Image.fromarray(np.uint8(mask))
-        mask = mask.rotate(r)
-        mask = np.asarray(mask)
-        mask = mask[(hh - h) // 2:(hh - h) // 2 + h, (ww - w) // 2:(ww - w) //
-                    2 + w]
-
-        if self.mode == 1:
-            mask = 1 - mask
-
-        mask = np.expand_dims(mask, axis=0)
-        img = (img * mask).astype(img.dtype)
-
-        return img

paddlex/ppcls/data/imaug/hide_and_seek.py

@@ -1,44 +0,0 @@
-# Copyright (c) 2020 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.
-
-# This code is based on https://github.com/kkanshul/Hide-and-Seek
-
-import numpy as np
-import random
-
-
-class HideAndSeek(object):
-    def __init__(self):
-        # possible grid size, 0 means no hiding
-        self.grid_sizes = [0, 16, 32, 44, 56]
-        # hiding probability
-        self.hide_prob = 0.5
-
-    def __call__(self, img):
-        # randomly choose one grid size
-        grid_size = np.random.choice(self.grid_sizes)
-
-        _, h, w = img.shape
-
-        # hide the patches
-        if grid_size == 0:
-            return img
-        for x in range(0, w, grid_size):
-            for y in range(0, h, grid_size):
-                x_end = min(w, x + grid_size)
-                y_end = min(h, y + grid_size)
-                if (random.random() <= self.hide_prob):
-                    img[:, x:x_end, y:y_end] = 0
-
-        return img

paddlex/ppcls/data/imaug/operators.py

@@ -1,256 +0,0 @@
-"""
-# Copyright (c) 2020 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.
-"""
-
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import six
-import math
-import random
-import cv2
-import numpy as np
-
-from .autoaugment import ImageNetPolicy
-
-
-class OperatorParamError(ValueError):
-    """ OperatorParamError
-    """
-    pass
-
-
-class DecodeImage(object):
-    """ decode image """
-
-    def __init__(self, to_rgb=True, to_np=False, channel_first=False):
-        self.to_rgb = to_rgb
-        self.to_np = to_np  # to numpy
-        self.channel_first = channel_first  # only enabled when to_np is True
-
-    def __call__(self, img):
-        if six.PY2:
-            assert type(img) is str and len(
-                img) > 0, "invalid input 'img' in DecodeImage"
-        else:
-            assert type(img) is bytes and len(
-                img) > 0, "invalid input 'img' in DecodeImage"
-        data = np.frombuffer(img, dtype='uint8')
-        img = cv2.imdecode(data, 1)
-        if self.to_rgb:
-            assert img.shape[2] == 3, 'invalid shape of image[%s]' % (
-                img.shape)
-            img = img[:, :, ::-1]
-
-        if self.channel_first:
-            img = img.transpose((2, 0, 1))
-
-        return img
-
-
-class ResizeImage(object):
-    """ resize image """
-
-    def __init__(self, size=None, resize_short=None, interpolation=-1):
-        self.interpolation = interpolation if interpolation >= 0 else None
-        if resize_short is not None and resize_short > 0:
-            self.resize_short = resize_short
-            self.w = None
-            self.h = None
-        elif size is not None:
-            self.resize_short = None
-            self.w = size if type(size) is int else size[0]
-            self.h = size if type(size) is int else size[1]
-        else:
-            raise OperatorParamError("invalid params for ReisizeImage for '\
-                'both 'size' and 'resize_short' are None")
-
-    def __call__(self, img):
-        img_h, img_w = img.shape[:2]
-        if self.resize_short is not None:
-            percent = float(self.resize_short) / min(img_w, img_h)
-            w = int(round(img_w * percent))
-            h = int(round(img_h * percent))
-        else:
-            w = self.w
-            h = self.h
-        if self.interpolation is None:
-            return cv2.resize(img, (w, h))
-        else:
-            return cv2.resize(img, (w, h), interpolation=self.interpolation)
-
-
-class CropImage(object):
-    """ crop image """
-
-    def __init__(self, size):
-        if type(size) is int:
-            self.size = (size, size)
-        else:
-            self.size = size  # (h, w)
-
-    def __call__(self, img):
-        w, h = self.size
-        img_h, img_w = img.shape[:2]
-        w_start = (img_w - w) // 2
-        h_start = (img_h - h) // 2
-
-        w_end = w_start + w
-        h_end = h_start + h
-        return img[h_start:h_end, w_start:w_end, :]
-
-
-class RandCropImage(object):
-    """ random crop image """
-
-    def __init__(self, size, scale=None, ratio=None, interpolation=-1):
-
-        self.interpolation = interpolation if interpolation >= 0 else None
-        if type(size) is int:
-            self.size = (size, size)  # (h, w)
-        else:
-            self.size = size
-
-        self.scale = [0.08, 1.0] if scale is None else scale
-        self.ratio = [3. / 4., 4. / 3.] if ratio is None else ratio
-
-    def __call__(self, img):
-        size = self.size
-        scale = self.scale
-        ratio = self.ratio
-
-        aspect_ratio = math.sqrt(random.uniform(*ratio))
-        w = 1. * aspect_ratio
-        h = 1. / aspect_ratio
-
-        img_h, img_w = img.shape[:2]
-
-        bound = min((float(img_w) / img_h) / (w**2),
-                    (float(img_h) / img_w) / (h**2))
-        scale_max = min(scale[1], bound)
-        scale_min = min(scale[0], bound)
-
-        target_area = img_w * img_h * random.uniform(scale_min, scale_max)
-        target_size = math.sqrt(target_area)
-        w = int(target_size * w)
-        h = int(target_size * h)
-
-        i = random.randint(0, img_w - w)
-        j = random.randint(0, img_h - h)
-
-        img = img[j:j + h, i:i + w, :]
-        if self.interpolation is None:
-            return cv2.resize(img, size)
-        else:
-            return cv2.resize(img, size, interpolation=self.interpolation)
-
-
-class RandFlipImage(object):
-    """ random flip image
-        flip_code:
-            1: Flipped Horizontally
-            0: Flipped Vertically
-            -1: Flipped Horizontally & Vertically
-    """
-
-    def __init__(self, flip_code=1):
-        assert flip_code in [-1, 0, 1
-                             ], "flip_code should be a value in [-1, 0, 1]"
-        self.flip_code = flip_code
-
-    def __call__(self, img):
-        if random.randint(0, 1) == 1:
-            return cv2.flip(img, self.flip_code)
-        else:
-            return img
-
-
-class AutoAugment(object):
-    def __init__(self):
-        self.policy = ImageNetPolicy()
-
-    def __call__(self, img):
-        from PIL import Image
-        img = np.ascontiguousarray(img)
-        img = Image.fromarray(img)
-        img = self.policy(img)
-        img = np.asarray(img)
-
-
-class NormalizeImage(object):
-    """ normalize image such as substract mean, divide std
-    """
-
-    def __init__(self,
-                 scale=None,
-                 mean=None,
-                 std=None,
-                 order='chw',
-                 output_fp16=False,
-                 channel_num=3):
-        if isinstance(scale, str):
-            scale = eval(scale)
-        assert channel_num in [
-            3, 4
-        ], "channel number of input image should be set to 3 or 4."
-        self.channel_num = channel_num
-        self.output_dtype = 'float16' if output_fp16 else 'float32'
-        self.scale = np.float32(scale if scale is not None else 1.0 / 255.0)
-        self.order = order
-        mean = mean if mean is not None else [0.485, 0.456, 0.406]
-        std = std if std is not None else [0.229, 0.224, 0.225]
-
-        shape = (3, 1, 1) if self.order == 'chw' else (1, 1, 3)
-        self.mean = np.array(mean).reshape(shape).astype('float32')
-        self.std = np.array(std).reshape(shape).astype('float32')
-
-    def __call__(self, img):
-        from PIL import Image
-        if isinstance(img, Image.Image):
-            img = np.array(img)
-
-        assert isinstance(img,
-                          np.ndarray), "invalid input 'img' in NormalizeImage"
-
-        img = (img.astype('float32') * self.scale - self.mean) / self.std
-
-        if self.channel_num == 4:
-            img_h = img.shape[1] if self.order == 'chw' else img.shape[0]
-            img_w = img.shape[2] if self.order == 'chw' else img.shape[1]
-            pad_zeros = np.zeros(
-                (1, img_h, img_w)) if self.order == 'chw' else np.zeros(
-                    (img_h, img_w, 1))
-            img = (np.concatenate(
-                (img, pad_zeros), axis=0)
-                   if self.order == 'chw' else np.concatenate(
-                       (img, pad_zeros), axis=2))
-        return img.astype(self.output_dtype)
-
-
-class ToCHWImage(object):
-    """ convert hwc image to chw image
-    """
-
-    def __init__(self):
-        pass
-
-    def __call__(self, img):
-        from PIL import Image
-        if isinstance(img, Image.Image):
-            img = np.array(img)
-
-        return img.transpose((2, 0, 1))

paddlex/ppcls/data/imaug/randaugment.py

@@ -1,106 +0,0 @@
-# Copyright (c) 2020 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.
-
-# This code is based on https://github.com/heartInsert/randaugment
-
-from PIL import Image, ImageEnhance, ImageOps
-import numpy as np
-import random
-
-
-class RandAugment(object):
-    def __init__(self, num_layers=2, magnitude=5, fillcolor=(128, 128, 128)):
-        self.num_layers = num_layers
-        self.magnitude = magnitude
-        self.max_level = 10
-
-        abso_level = self.magnitude / self.max_level
-        self.level_map = {
-            "shearX": 0.3 * abso_level,
-            "shearY": 0.3 * abso_level,
-            "translateX": 150.0 / 331 * abso_level,
-            "translateY": 150.0 / 331 * abso_level,
-            "rotate": 30 * abso_level,
-            "color": 0.9 * abso_level,
-            "posterize": int(4.0 * abso_level),
-            "solarize": 256.0 * abso_level,
-            "contrast": 0.9 * abso_level,
-            "sharpness": 0.9 * abso_level,
-            "brightness": 0.9 * abso_level,
-            "autocontrast": 0,
-            "equalize": 0,
-            "invert": 0
-        }
-
-        # from https://stackoverflow.com/questions/5252170/
-        # specify-image-filling-color-when-rotating-in-python-with-pil-and-setting-expand
-        def rotate_with_fill(img, magnitude):
-            rot = img.convert("RGBA").rotate(magnitude)
-            return Image.composite(rot,
-                                   Image.new("RGBA", rot.size, (128, ) * 4),
-                                   rot).convert(img.mode)
-
-        rnd_ch_op = random.choice
-
-        self.func = {
-            "shearX": lambda img, magnitude: img.transform(
-                img.size,
-                Image.AFFINE,
-                (1, magnitude * rnd_ch_op([-1, 1]), 0, 0, 1, 0),
-                Image.BICUBIC,
-                fillcolor=fillcolor),
-            "shearY": lambda img, magnitude: img.transform(
-                img.size,
-                Image.AFFINE,
-                (1, 0, 0, magnitude * rnd_ch_op([-1, 1]), 1, 0),
-                Image.BICUBIC,
-                fillcolor=fillcolor),
-            "translateX": lambda img, magnitude: img.transform(
-                img.size,
-                Image.AFFINE,
-                (1, 0, magnitude * img.size[0] * rnd_ch_op([-1, 1]), 0, 1, 0),
-                fillcolor=fillcolor),
-            "translateY": lambda img, magnitude: img.transform(
-                img.size,
-                Image.AFFINE,
-                (1, 0, 0, 0, 1, magnitude * img.size[1] * rnd_ch_op([-1, 1])),
-                fillcolor=fillcolor),
-            "rotate": lambda img, magnitude: rotate_with_fill(img, magnitude),
-            "color": lambda img, magnitude: ImageEnhance.Color(img).enhance(
-                1 + magnitude * rnd_ch_op([-1, 1])),
-            "posterize": lambda img, magnitude:
-                ImageOps.posterize(img, magnitude),
-            "solarize": lambda img, magnitude:
-                ImageOps.solarize(img, magnitude),
-            "contrast": lambda img, magnitude:
-                ImageEnhance.Contrast(img).enhance(
-                    1 + magnitude * rnd_ch_op([-1, 1])),
-            "sharpness": lambda img, magnitude:
-                ImageEnhance.Sharpness(img).enhance(
-                    1 + magnitude * rnd_ch_op([-1, 1])),
-            "brightness": lambda img, magnitude:
-                ImageEnhance.Brightness(img).enhance(
-                    1 + magnitude * rnd_ch_op([-1, 1])),
-            "autocontrast": lambda img, magnitude:
-                ImageOps.autocontrast(img),
-            "equalize": lambda img, magnitude: ImageOps.equalize(img),
-            "invert": lambda img, magnitude: ImageOps.invert(img)
-        }
-
-    def __call__(self, img):
-        avaiable_op_names = list(self.level_map.keys())
-        for layer_num in range(self.num_layers):
-            op_name = np.random.choice(avaiable_op_names)
-            img = self.func[op_name](img, self.level_map[op_name])
-        return img

paddlex/ppcls/data/imaug/random_erasing.py

@@ -1,55 +0,0 @@
-# Copyright (c) 2020 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.
-
-#This code is based on https://github.com/zhunzhong07/Random-Erasing
-
-import math
-import random
-
-import numpy as np
-
-
-class RandomErasing(object):
-    def __init__(self, EPSILON=0.5, sl=0.02, sh=0.4, r1=0.3,
-                 mean=[0., 0., 0.]):
-        self.EPSILON = EPSILON
-        self.mean = mean
-        self.sl = sl
-        self.sh = sh
-        self.r1 = r1
-
-    def __call__(self, img):
-        if random.uniform(0, 1) > self.EPSILON:
-            return img
-
-        for attempt in range(100):
-            area = img.shape[1] * img.shape[2]
-
-            target_area = random.uniform(self.sl, self.sh) * area
-            aspect_ratio = random.uniform(self.r1, 1 / self.r1)
-
-            h = int(round(math.sqrt(target_area * aspect_ratio)))
-            w = int(round(math.sqrt(target_area / aspect_ratio)))
-
-            if w < img.shape[2] and h < img.shape[1]:
-                x1 = random.randint(0, img.shape[1] - h)
-                y1 = random.randint(0, img.shape[2] - w)
-                if img.shape[0] == 3:
-                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]
-                    img[1, x1:x1 + h, y1:y1 + w] = self.mean[1]
-                    img[2, x1:x1 + h, y1:y1 + w] = self.mean[2]
-                else:
-                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[1]
-                return img
-        return img