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

paddlex/ppcls/data/imaug/autoaugment.py

@@ -1,264 +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/DeepVoltaire/AutoAugment/blob/master/autoaugment.py
-
-from PIL import Image, ImageEnhance, ImageOps
-import numpy as np
-import random
-
-
-class ImageNetPolicy(object):
-    """ Randomly choose one of the best 24 Sub-policies on ImageNet.
-
-        Example:
-        >>> policy = ImageNetPolicy()
-        >>> transformed = policy(image)
-
-        Example as a PyTorch Transform:
-        >>> transform=transforms.Compose([
-        >>>     transforms.Resize(256),
-        >>>     ImageNetPolicy(),
-        >>>     transforms.ToTensor()])
-    """
-
-    def __init__(self, fillcolor=(128, 128, 128)):
-        self.policies = [
-            SubPolicy(0.4, "posterize", 8, 0.6, "rotate", 9, fillcolor),
-            SubPolicy(0.6, "solarize", 5, 0.6, "autocontrast", 5, fillcolor),
-            SubPolicy(0.8, "equalize", 8, 0.6, "equalize", 3, fillcolor),
-            SubPolicy(0.6, "posterize", 7, 0.6, "posterize", 6, fillcolor),
-            SubPolicy(0.4, "equalize", 7, 0.2, "solarize", 4, fillcolor),
-            SubPolicy(0.4, "equalize", 4, 0.8, "rotate", 8, fillcolor),
-            SubPolicy(0.6, "solarize", 3, 0.6, "equalize", 7, fillcolor),
-            SubPolicy(0.8, "posterize", 5, 1.0, "equalize", 2, fillcolor),
-            SubPolicy(0.2, "rotate", 3, 0.6, "solarize", 8, fillcolor),
-            SubPolicy(0.6, "equalize", 8, 0.4, "posterize", 6, fillcolor),
-            SubPolicy(0.8, "rotate", 8, 0.4, "color", 0, fillcolor),
-            SubPolicy(0.4, "rotate", 9, 0.6, "equalize", 2, fillcolor),
-            SubPolicy(0.0, "equalize", 7, 0.8, "equalize", 8, fillcolor),
-            SubPolicy(0.6, "invert", 4, 1.0, "equalize", 8, fillcolor),
-            SubPolicy(0.6, "color", 4, 1.0, "contrast", 8, fillcolor),
-            SubPolicy(0.8, "rotate", 8, 1.0, "color", 2, fillcolor),
-            SubPolicy(0.8, "color", 8, 0.8, "solarize", 7, fillcolor),
-            SubPolicy(0.4, "sharpness", 7, 0.6, "invert", 8, fillcolor),
-            SubPolicy(0.6, "shearX", 5, 1.0, "equalize", 9, fillcolor),
-            SubPolicy(0.4, "color", 0, 0.6, "equalize", 3, fillcolor),
-            SubPolicy(0.4, "equalize", 7, 0.2, "solarize", 4, fillcolor),
-            SubPolicy(0.6, "solarize", 5, 0.6, "autocontrast", 5, fillcolor),
-            SubPolicy(0.6, "invert", 4, 1.0, "equalize", 8, fillcolor),
-            SubPolicy(0.6, "color", 4, 1.0, "contrast", 8, fillcolor),
-            SubPolicy(0.8, "equalize", 8, 0.6, "equalize", 3, fillcolor)
-        ]
-
-    def __call__(self, img, policy_idx=None):
-        if policy_idx is None or not isinstance(policy_idx, int):
-            policy_idx = random.randint(0, len(self.policies) - 1)
-        else:
-            policy_idx = policy_idx % len(self.policies)
-        return self.policies[policy_idx](img)
-
-    def __repr__(self):
-        return "AutoAugment ImageNet Policy"
-
-
-class CIFAR10Policy(object):
-    """ Randomly choose one of the best 25 Sub-policies on CIFAR10.
-
-        Example:
-        >>> policy = CIFAR10Policy()
-        >>> transformed = policy(image)
-
-        Example as a PyTorch Transform:
-        >>> transform=transforms.Compose([
-        >>>     transforms.Resize(256),
-        >>>     CIFAR10Policy(),
-        >>>     transforms.ToTensor()])
-    """
-
-    def __init__(self, fillcolor=(128, 128, 128)):
-        self.policies = [
-            SubPolicy(0.1, "invert", 7, 0.2, "contrast", 6, fillcolor),
-            SubPolicy(0.7, "rotate", 2, 0.3, "translateX", 9, fillcolor),
-            SubPolicy(0.8, "sharpness", 1, 0.9, "sharpness", 3, fillcolor),
-            SubPolicy(0.5, "shearY", 8, 0.7, "translateY", 9, fillcolor),
-            SubPolicy(0.5, "autocontrast", 8, 0.9, "equalize", 2, fillcolor),
-            SubPolicy(0.2, "shearY", 7, 0.3, "posterize", 7, fillcolor),
-            SubPolicy(0.4, "color", 3, 0.6, "brightness", 7, fillcolor),
-            SubPolicy(0.3, "sharpness", 9, 0.7, "brightness", 9, fillcolor),
-            SubPolicy(0.6, "equalize", 5, 0.5, "equalize", 1, fillcolor),
-            SubPolicy(0.6, "contrast", 7, 0.6, "sharpness", 5, fillcolor),
-            SubPolicy(0.7, "color", 7, 0.5, "translateX", 8, fillcolor),
-            SubPolicy(0.3, "equalize", 7, 0.4, "autocontrast", 8, fillcolor),
-            SubPolicy(0.4, "translateY", 3, 0.2, "sharpness", 6, fillcolor),
-            SubPolicy(0.9, "brightness", 6, 0.2, "color", 8, fillcolor),
-            SubPolicy(0.5, "solarize", 2, 0.0, "invert", 3, fillcolor),
-            SubPolicy(0.2, "equalize", 0, 0.6, "autocontrast", 0, fillcolor),
-            SubPolicy(0.2, "equalize", 8, 0.8, "equalize", 4, fillcolor),
-            SubPolicy(0.9, "color", 9, 0.6, "equalize", 6, fillcolor),
-            SubPolicy(0.8, "autocontrast", 4, 0.2, "solarize", 8, fillcolor),
-            SubPolicy(0.1, "brightness", 3, 0.7, "color", 0, fillcolor),
-            SubPolicy(0.4, "solarize", 5, 0.9, "autocontrast", 3, fillcolor),
-            SubPolicy(0.9, "translateY", 9, 0.7, "translateY", 9, fillcolor),
-            SubPolicy(0.9, "autocontrast", 2, 0.8, "solarize", 3, fillcolor),
-            SubPolicy(0.8, "equalize", 8, 0.1, "invert", 3, fillcolor),
-            SubPolicy(0.7, "translateY", 9, 0.9, "autocontrast", 1, fillcolor)
-        ]
-
-    def __call__(self, img, policy_idx=None):
-        if policy_idx is None or not isinstance(policy_idx, int):
-            policy_idx = random.randint(0, len(self.policies) - 1)
-        else:
-            policy_idx = policy_idx % len(self.policies)
-        return self.policies[policy_idx](img)
-
-    def __repr__(self):
-        return "AutoAugment CIFAR10 Policy"
-
-
-class SVHNPolicy(object):
-    """ Randomly choose one of the best 25 Sub-policies on SVHN.
-
-        Example:
-        >>> policy = SVHNPolicy()
-        >>> transformed = policy(image)
-
-        Example as a PyTorch Transform:
-        >>> transform=transforms.Compose([
-        >>>     transforms.Resize(256),
-        >>>     SVHNPolicy(),
-        >>>     transforms.ToTensor()])
-    """
-
-    def __init__(self, fillcolor=(128, 128, 128)):
-        self.policies = [
-            SubPolicy(0.9, "shearX", 4, 0.2, "invert", 3, fillcolor),
-            SubPolicy(0.9, "shearY", 8, 0.7, "invert", 5, fillcolor),
-            SubPolicy(0.6, "equalize", 5, 0.6, "solarize", 6, fillcolor),
-            SubPolicy(0.9, "invert", 3, 0.6, "equalize", 3, fillcolor),
-            SubPolicy(0.6, "equalize", 1, 0.9, "rotate", 3, fillcolor),
-            SubPolicy(0.9, "shearX", 4, 0.8, "autocontrast", 3, fillcolor),
-            SubPolicy(0.9, "shearY", 8, 0.4, "invert", 5, fillcolor),
-            SubPolicy(0.9, "shearY", 5, 0.2, "solarize", 6, fillcolor),
-            SubPolicy(0.9, "invert", 6, 0.8, "autocontrast", 1, fillcolor),
-            SubPolicy(0.6, "equalize", 3, 0.9, "rotate", 3, fillcolor),
-            SubPolicy(0.9, "shearX", 4, 0.3, "solarize", 3, fillcolor),
-            SubPolicy(0.8, "shearY", 8, 0.7, "invert", 4, fillcolor),
-            SubPolicy(0.9, "equalize", 5, 0.6, "translateY", 6, fillcolor),
-            SubPolicy(0.9, "invert", 4, 0.6, "equalize", 7, fillcolor),
-            SubPolicy(0.3, "contrast", 3, 0.8, "rotate", 4, fillcolor),
-            SubPolicy(0.8, "invert", 5, 0.0, "translateY", 2, fillcolor),
-            SubPolicy(0.7, "shearY", 6, 0.4, "solarize", 8, fillcolor),
-            SubPolicy(0.6, "invert", 4, 0.8, "rotate", 4, fillcolor),
-            SubPolicy(
-                0.3, "shearY", 7, 0.9, "translateX", 3, fillcolor), SubPolicy(
-                    0.1, "shearX", 6, 0.6, "invert", 5, fillcolor), SubPolicy(
-                        0.7, "solarize", 2, 0.6, "translateY", 7,
-                        fillcolor), SubPolicy(0.8, "shearY", 4, 0.8, "invert",
-                                              8, fillcolor), SubPolicy(
-                                                  0.7, "shearX", 9, 0.8,
-                                                  "translateY", 3,
-                                                  fillcolor), SubPolicy(
-                                                      0.8, "shearY", 5, 0.7,
-                                                      "autocontrast", 3,
-                                                      fillcolor),
-            SubPolicy(0.7, "shearX", 2, 0.1, "invert", 5, fillcolor)
-        ]
-
-    def __call__(self, img, policy_idx=None):
-        if policy_idx is None or not isinstance(policy_idx, int):
-            policy_idx = random.randint(0, len(self.policies) - 1)
-        else:
-            policy_idx = policy_idx % len(self.policies)
-        return self.policies[policy_idx](img)
-
-    def __repr__(self):
-        return "AutoAugment SVHN Policy"
-
-
-class SubPolicy(object):
-    def __init__(self,
-                 p1,
-                 operation1,
-                 magnitude_idx1,
-                 p2,
-                 operation2,
-                 magnitude_idx2,
-                 fillcolor=(128, 128, 128)):
-        ranges = {
-            "shearX": np.linspace(0, 0.3, 10),
-            "shearY": np.linspace(0, 0.3, 10),
-            "translateX": np.linspace(0, 150 / 331, 10),
-            "translateY": np.linspace(0, 150 / 331, 10),
-            "rotate": np.linspace(0, 30, 10),
-            "color": np.linspace(0.0, 0.9, 10),
-            "posterize": np.round(np.linspace(8, 4, 10), 0).astype(np.int),
-            "solarize": np.linspace(256, 0, 10),
-            "contrast": np.linspace(0.0, 0.9, 10),
-            "sharpness": np.linspace(0.0, 0.9, 10),
-            "brightness": np.linspace(0.0, 0.9, 10),
-            "autocontrast": [0] * 10,
-            "equalize": [0] * 10,
-            "invert": [0] * 10
-        }
-
-        # 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)
-
-        func = {
-            "shearX": lambda img, magnitude: img.transform(
-                img.size, Image.AFFINE, (1, magnitude * random.choice([-1, 1]), 0, 0, 1, 0),
-                Image.BICUBIC, fillcolor=fillcolor),
-            "shearY": lambda img, magnitude: img.transform(
-                img.size, Image.AFFINE, (1, 0, 0, magnitude * random.choice([-1, 1]), 1, 0),
-                Image.BICUBIC, fillcolor=fillcolor),
-            "translateX": lambda img, magnitude: img.transform(
-                img.size, Image.AFFINE, (1, 0, magnitude * img.size[0] * random.choice([-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] * random.choice([-1, 1])),
-                fillcolor=fillcolor),
-            "rotate": lambda img, magnitude: rotate_with_fill(img, magnitude),
-            # "rotate": lambda img, magnitude: img.rotate(magnitude * random.choice([-1, 1])),
-            "color": lambda img, magnitude: ImageEnhance.Color(img).enhance(1 + magnitude * random.choice([-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 * random.choice([-1, 1])),
-            "sharpness": lambda img, magnitude: ImageEnhance.Sharpness(img).enhance(
-                1 + magnitude * random.choice([-1, 1])),
-            "brightness": lambda img, magnitude: ImageEnhance.Brightness(img).enhance(
-                1 + magnitude * random.choice([-1, 1])),
-            "autocontrast": lambda img, magnitude: ImageOps.autocontrast(img),
-            "equalize": lambda img, magnitude: ImageOps.equalize(img),
-            "invert": lambda img, magnitude: ImageOps.invert(img)
-        }
-
-        self.p1 = p1
-        self.operation1 = func[operation1]
-        self.magnitude1 = ranges[operation1][magnitude_idx1]
-        self.p2 = p2
-        self.operation2 = func[operation2]
-        self.magnitude2 = ranges[operation2][magnitude_idx2]
-
-    def __call__(self, img):
-        if random.random() < self.p1:
-            img = self.operation1(img, self.magnitude1)
-        if random.random() < self.p2:
-            img = self.operation2(img, self.magnitude2)
-        return img

paddlex/ppcls/data/imaug/batch_operators.py

@@ -1,117 +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 numpy as np
-
-from .fmix import sample_mask
-
-
-class BatchOperator(object):
-    """ BatchOperator """
-
-    def __init__(self, *args, **kwargs):
-        pass
-
-    def _unpack(self, batch):
-        """ _unpack """
-        assert isinstance(batch, list), \
-                'batch should be a list filled with tuples (img, label)'
-        bs = len(batch)
-        assert bs > 0, 'size of the batch data should > 0'
-        imgs, labels = list(zip(*batch))
-        return np.array(imgs), np.array(labels), bs
-
-    def __call__(self, batch):
-        return batch
-
-
-class MixupOperator(BatchOperator):
-    """ Mixup operator """
-
-    def __init__(self, alpha=0.2):
-        assert alpha > 0., \
-                'parameter alpha[%f] should > 0.0' % (alpha)
-        self._alpha = alpha
-
-    def __call__(self, batch):
-        imgs, labels, bs = self._unpack(batch)
-        idx = np.random.permutation(bs)
-        lam = np.random.beta(self._alpha, self._alpha)
-        lams = np.array([lam] * bs, dtype=np.float32)
-        imgs = lam * imgs + (1 - lam) * imgs[idx]
-        return list(zip(imgs, labels, labels[idx], lams))
-
-
-class CutmixOperator(BatchOperator):
-    """ Cutmix operator """
-
-    def __init__(self, alpha=0.2):
-        assert alpha > 0., \
-                'parameter alpha[%f] should > 0.0' % (alpha)
-        self._alpha = alpha
-
-    def _rand_bbox(self, size, lam):
-        """ _rand_bbox """
-        w = size[2]
-        h = size[3]
-        cut_rat = np.sqrt(1. - lam)
-        cut_w = np.int(w * cut_rat)
-        cut_h = np.int(h * cut_rat)
-
-        # uniform
-        cx = np.random.randint(w)
-        cy = np.random.randint(h)
-
-        bbx1 = np.clip(cx - cut_w // 2, 0, w)
-        bby1 = np.clip(cy - cut_h // 2, 0, h)
-        bbx2 = np.clip(cx + cut_w // 2, 0, w)
-        bby2 = np.clip(cy + cut_h // 2, 0, h)
-
-        return bbx1, bby1, bbx2, bby2
-
-    def __call__(self, batch):
-        imgs, labels, bs = self._unpack(batch)
-        idx = np.random.permutation(bs)
-        lam = np.random.beta(self._alpha, self._alpha)
-
-        bbx1, bby1, bbx2, bby2 = self._rand_bbox(imgs.shape, lam)
-        imgs[:, :, bbx1:bbx2, bby1:bby2] = imgs[idx, :, bbx1:bbx2, bby1:bby2]
-        lam = 1 - (float(bbx2 - bbx1) * (bby2 - bby1) /
-                   (imgs.shape[-2] * imgs.shape[-1]))
-        lams = np.array([lam] * bs, dtype=np.float32)
-        return list(zip(imgs, labels, labels[idx], lams))
-
-
-class FmixOperator(BatchOperator):
-    """ Fmix operator """
-
-    def __init__(self, alpha=1, decay_power=3, max_soft=0., reformulate=False):
-        self._alpha = alpha
-        self._decay_power = decay_power
-        self._max_soft = max_soft
-        self._reformulate = reformulate
-
-    def __call__(self, batch):
-        imgs, labels, bs = self._unpack(batch)
-        idx = np.random.permutation(bs)
-        size = (imgs.shape[2], imgs.shape[3])
-        lam, mask = sample_mask(self._alpha, self._decay_power, \
-                size, self._max_soft, self._reformulate)
-        imgs = mask * imgs + (1 - mask) * imgs[idx]
-        return list(zip(imgs, labels, labels[idx], [lam] * bs))

paddlex/ppcls/data/imaug/cutout.py

@@ -1,41 +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/uoguelph-mlrg/Cutout
-
-import numpy as np
-import random
-
-
-class Cutout(object):
-    def __init__(self, n_holes=1, length=112):
-        self.n_holes = n_holes
-        self.length = length
-
-    def __call__(self, img):
-        """ cutout_image """
-        h, w = img.shape[:2]
-        mask = np.ones((h, w), np.float32)
-
-        for n in range(self.n_holes):
-            y = np.random.randint(h)
-            x = np.random.randint(w)
-
-            y1 = np.clip(y - self.length // 2, 0, h)
-            y2 = np.clip(y + self.length // 2, 0, h)
-            x1 = np.clip(x - self.length // 2, 0, w)
-            x2 = np.clip(x + self.length // 2, 0, w)
-
-            img[y1:y2, x1:x2] = 0
-        return img

paddlex/ppcls/data/imaug/fmix.py

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