paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

PaddleClas/ppcls/data/preprocess/ops/fmix.py

@@ -1,217 +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 math
-import random
-
-import numpy as np
-from scipy.stats import beta
-
-
-def fftfreqnd(h, w=None, z=None):
-    """ Get bin values for discrete fourier transform of size (h, w, z)
-
-    :param h: Required, first dimension size
-    :param w: Optional, second dimension size
-    :param z: Optional, third dimension size
-    """
-    fz = fx = 0
-    fy = np.fft.fftfreq(h)
-
-    if w is not None:
-        fy = np.expand_dims(fy, -1)
-
-        if w % 2 == 1:
-            fx = np.fft.fftfreq(w)[:w // 2 + 2]
-        else:
-            fx = np.fft.fftfreq(w)[:w // 2 + 1]
-
-    if z is not None:
-        fy = np.expand_dims(fy, -1)
-        if z % 2 == 1:
-            fz = np.fft.fftfreq(z)[:, None]
-        else:
-            fz = np.fft.fftfreq(z)[:, None]
-
-    return np.sqrt(fx * fx + fy * fy + fz * fz)
-
-
-def get_spectrum(freqs, decay_power, ch, h, w=0, z=0):
-    """ Samples a fourier image with given size and frequencies decayed by decay power
-
-    :param freqs: Bin values for the discrete fourier transform
-    :param decay_power: Decay power for frequency decay prop 1/f**d
-    :param ch: Number of channels for the resulting mask
-    :param h: Required, first dimension size
-    :param w: Optional, second dimension size
-    :param z: Optional, third dimension size
-    """
-    scale = np.ones(1) / (np.maximum(freqs, np.array([1. / max(w, h, z)]))
-                          **decay_power)
-
-    param_size = [ch] + list(freqs.shape) + [2]
-    param = np.random.randn(*param_size)
-
-    scale = np.expand_dims(scale, -1)[None, :]
-
-    return scale * param
-
-
-def make_low_freq_image(decay, shape, ch=1):
-    """ Sample a low frequency image from fourier space
-
-    :param decay_power: Decay power for frequency decay prop 1/f**d
-    :param shape: Shape of desired mask, list up to 3 dims
-    :param ch: Number of channels for desired mask
-    """
-    freqs = fftfreqnd(*shape)
-    spectrum = get_spectrum(freqs, decay, ch,
-                            *shape)  #.reshape((1, *shape[:-1], -1))
-    spectrum = spectrum[:, 0] + 1j * spectrum[:, 1]
-    mask = np.real(np.fft.irfftn(spectrum, shape))
-
-    if len(shape) == 1:
-        mask = mask[:1, :shape[0]]
-    if len(shape) == 2:
-        mask = mask[:1, :shape[0], :shape[1]]
-    if len(shape) == 3:
-        mask = mask[:1, :shape[0], :shape[1], :shape[2]]
-
-    mask = mask
-    mask = (mask - mask.min())
-    mask = mask / mask.max()
-    return mask
-
-
-def sample_lam(alpha, reformulate=False):
-    """ Sample a lambda from symmetric beta distribution with given alpha
-
-    :param alpha: Alpha value for beta distribution
-    :param reformulate: If True, uses the reformulation of [1].
-    """
-    if reformulate:
-        lam = beta.rvs(alpha + 1, alpha)
-    else:
-        lam = beta.rvs(alpha, alpha)
-
-    return lam
-
-
-def binarise_mask(mask, lam, in_shape, max_soft=0.0):
-    """ Binarises a given low frequency image such that it has mean lambda.
-
-    :param mask: Low frequency image, usually the result of `make_low_freq_image`
-    :param lam: Mean value of final mask
-    :param in_shape: Shape of inputs
-    :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask.
-    :return:
-    """
-    idx = mask.reshape(-1).argsort()[::-1]
-    mask = mask.reshape(-1)
-    num = math.ceil(lam * mask.size) if random.random() > 0.5 else math.floor(
-        lam * mask.size)
-
-    eff_soft = max_soft
-    if max_soft > lam or max_soft > (1 - lam):
-        eff_soft = min(lam, 1 - lam)
-
-    soft = int(mask.size * eff_soft)
-    num_low = int(num - soft)
-    num_high = int(num + soft)
-
-    mask[idx[:num_high]] = 1
-    mask[idx[num_low:]] = 0
-    mask[idx[num_low:num_high]] = np.linspace(1, 0, (num_high - num_low))
-
-    mask = mask.reshape((1, 1, in_shape[0], in_shape[1]))
-    return mask
-
-
-def sample_mask(alpha, decay_power, shape, max_soft=0.0, reformulate=False):
-    """ Samples a mean lambda from beta distribution parametrised by alpha, creates a low frequency image and binarises
-    it based on this lambda
-
-    :param alpha: Alpha value for beta distribution from which to sample mean of mask
-    :param decay_power: Decay power for frequency decay prop 1/f**d
-    :param shape: Shape of desired mask, list up to 3 dims
-    :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask.
-    :param reformulate: If True, uses the reformulation of [1].
-    """
-    if isinstance(shape, int):
-        shape = (shape, )
-
-    # Choose lambda
-    lam = sample_lam(alpha, reformulate)
-
-    # Make mask, get mean / std
-    mask = make_low_freq_image(decay_power, shape)
-    mask = binarise_mask(mask, lam, shape, max_soft)
-
-    return float(lam), mask
-
-
-def sample_and_apply(x,
-                     alpha,
-                     decay_power,
-                     shape,
-                     max_soft=0.0,
-                     reformulate=False):
-    """
-
-    :param x: Image batch on which to apply fmix of shape [b, c, shape*]
-    :param alpha: Alpha value for beta distribution from which to sample mean of mask
-    :param decay_power: Decay power for frequency decay prop 1/f**d
-    :param shape: Shape of desired mask, list up to 3 dims
-    :param max_soft: Softening value between 0 and 0.5 which smooths hard edges in the mask.
-    :param reformulate: If True, uses the reformulation of [1].
-    :return: mixed input, permutation indices, lambda value of mix,
-    """
-    lam, mask = sample_mask(alpha, decay_power, shape, max_soft, reformulate)
-    index = np.random.permutation(x.shape[0])
-
-    x1, x2 = x * mask, x[index] * (1 - mask)
-    return x1 + x2, index, lam
-
-
-class FMixBase:
-    """ FMix augmentation
-
-        Args:
-            decay_power (float): Decay power for frequency decay prop 1/f**d
-            alpha (float): Alpha value for beta distribution from which to sample mean of mask
-            size ([int] | [int, int] | [int, int, int]): Shape of desired mask, list up to 3 dims
-            max_soft (float): Softening value between 0 and 0.5 which smooths hard edges in the mask.
-            reformulate (bool): If True, uses the reformulation of [1].
-    """
-
-    def __init__(self,
-                 decay_power=3,
-                 alpha=1,
-                 size=(32, 32),
-                 max_soft=0.0,
-                 reformulate=False):
-        super().__init__()
-        self.decay_power = decay_power
-        self.reformulate = reformulate
-        self.size = size
-        self.alpha = alpha
-        self.max_soft = max_soft
-        self.index = None
-        self.lam = None
-
-    def __call__(self, x):
-        raise NotImplementedError
-
-    def loss(self, *args, **kwargs):
-        raise NotImplementedError

PaddleClas/ppcls/data/preprocess/ops/functional.py

@@ -1,138 +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.
-
-# encoding: utf-8
-
-import numpy as np
-from PIL import Image, ImageOps, ImageEnhance
-
-
-
-def int_parameter(level, maxval):
-    """Helper function to scale `val` between 0 and maxval .
-    Args:
-      level: Level of the operation that will be between [0, `PARAMETER_MAX`].
-      maxval: Maximum value that the operation can have. This will be scaled to
-        level/PARAMETER_MAX.
-    Returns:
-      An int that results from scaling `maxval` according to `level`.
-    """
-    return int(level * maxval / 10)
-
-
-def float_parameter(level, maxval):
-    """Helper function to scale `val` between 0 and maxval.
-    Args:
-      level: Level of the operation that will be between [0, `PARAMETER_MAX`].
-      maxval: Maximum value that the operation can have. This will be scaled to
-        level/PARAMETER_MAX.
-    Returns:
-      A float that results from scaling `maxval` according to `level`.
-    """
-    return float(level) * maxval / 10.
-
-
-def sample_level(n):
-    return np.random.uniform(low=0.1, high=n)
-
-
-def autocontrast(pil_img, *args):
-    return ImageOps.autocontrast(pil_img)
-
-
-def equalize(pil_img, *args):
-    return ImageOps.equalize(pil_img)
-
-
-def posterize(pil_img, level, *args):
-    level = int_parameter(sample_level(level), 4)
-    return ImageOps.posterize(pil_img, 4 - level)
-
-
-def rotate(pil_img, level, *args):
-    degrees = int_parameter(sample_level(level), 30)
-    if np.random.uniform() > 0.5:
-        degrees = -degrees
-    return pil_img.rotate(degrees, resample=Image.BILINEAR)
-
-
-def solarize(pil_img, level, *args):
-    level = int_parameter(sample_level(level), 256)
-    return ImageOps.solarize(pil_img, 256 - level)
-
-
-def shear_x(pil_img, level):
-    level = float_parameter(sample_level(level), 0.3)
-    if np.random.uniform() > 0.5:
-        level = -level
-    return pil_img.transform(pil_img.size,
-                             Image.AFFINE, (1, level, 0, 0, 1, 0),
-                             resample=Image.BILINEAR)
-
-
-def shear_y(pil_img, level):
-    level = float_parameter(sample_level(level), 0.3)
-    if np.random.uniform() > 0.5:
-        level = -level
-    return pil_img.transform(pil_img.size,
-                             Image.AFFINE, (1, 0, 0, level, 1, 0),
-                             resample=Image.BILINEAR)
-
-
-def translate_x(pil_img, level):
-    level = int_parameter(sample_level(level), pil_img.size[0] / 3)
-    if np.random.random() > 0.5:
-        level = -level
-    return pil_img.transform(pil_img.size,
-                             Image.AFFINE, (1, 0, level, 0, 1, 0),
-                             resample=Image.BILINEAR)
-
-
-def translate_y(pil_img, level):
-    level = int_parameter(sample_level(level), pil_img.size[1] / 3)
-    if np.random.random() > 0.5:
-        level = -level
-    return pil_img.transform(pil_img.size,
-                             Image.AFFINE, (1, 0, 0, 0, 1, level),
-                             resample=Image.BILINEAR)
-
-
-# operation that overlaps with ImageNet-C's test set
-def color(pil_img, level, *args):
-    level = float_parameter(sample_level(level), 1.8) + 0.1
-    return ImageEnhance.Color(pil_img).enhance(level)
-
-
-# operation that overlaps with ImageNet-C's test set
-def contrast(pil_img, level, *args):
-    level = float_parameter(sample_level(level), 1.8) + 0.1
-    return ImageEnhance.Contrast(pil_img).enhance(level)
-
-
-# operation that overlaps with ImageNet-C's test set
-def brightness(pil_img, level, *args):
-    level = float_parameter(sample_level(level), 1.8) + 0.1
-    return ImageEnhance.Brightness(pil_img).enhance(level)
-
-
-# operation that overlaps with ImageNet-C's test set
-def sharpness(pil_img, level, *args):
-    level = float_parameter(sample_level(level), 1.8) + 0.1
-    return ImageEnhance.Sharpness(pil_img).enhance(level)
-
-
-augmentations = [
-    autocontrast, equalize, posterize, rotate, solarize, shear_x, shear_y,
-    translate_x, translate_y
-]

PaddleClas/ppcls/data/preprocess/ops/grid.py

@@ -1,89 +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.
-
-# 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

PaddleClas/ppcls/data/preprocess/ops/hide_and_seek.py

@@ -1,44 +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.
-
-# 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