pyxllib 0.3.96__py3-none-any.whl → 0.3.200__py3-none-any.whl

pyxlpr/ppocr/modeling/transforms/tps_spatial_transformer.py

@@ -1,156 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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 refer from:
-https://github.com/ayumiymk/aster.pytorch/blob/master/lib/models/tps_spatial_transformer.py
-"""
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-import paddle
-from paddle import nn, ParamAttr
-from paddle.nn import functional as F
-import numpy as np
-import itertools
-
-
-def grid_sample(input, grid, canvas=None):
-    input.stop_gradient = False
-    output = F.grid_sample(input, grid)
-    if canvas is None:
-        return output
-    else:
-        input_mask = paddle.ones(shape=input.shape)
-        output_mask = F.grid_sample(input_mask, grid)
-        padded_output = output * output_mask + canvas * (1 - output_mask)
-        return padded_output
-
-
-# phi(x1, x2) = r^2 * log(r), where r = ||x1 - x2||_2
-def compute_partial_repr(input_points, control_points):
-    N = input_points.shape[0]
-    M = control_points.shape[0]
-    pairwise_diff = paddle.reshape(
-        input_points, shape=[N, 1, 2]) - paddle.reshape(
-            control_points, shape=[1, M, 2])
-    # original implementation, very slow
-    # pairwise_dist = torch.sum(pairwise_diff ** 2, dim = 2) # square of distance
-    pairwise_diff_square = pairwise_diff * pairwise_diff
-    pairwise_dist = pairwise_diff_square[:, :, 0] + pairwise_diff_square[:, :,
-                                                                         1]
-    repr_matrix = 0.5 * pairwise_dist * paddle.log(pairwise_dist)
-    # fix numerical error for 0 * log(0), substitute all nan with 0
-    mask = np.array(repr_matrix != repr_matrix)
-    repr_matrix[mask] = 0
-    return repr_matrix
-
-
-# output_ctrl_pts are specified, according to our task.
-def build_output_control_points(num_control_points, margins):
-    margin_x, margin_y = margins
-    num_ctrl_pts_per_side = num_control_points // 2
-    ctrl_pts_x = np.linspace(margin_x, 1.0 - margin_x, num_ctrl_pts_per_side)
-    ctrl_pts_y_top = np.ones(num_ctrl_pts_per_side) * margin_y
-    ctrl_pts_y_bottom = np.ones(num_ctrl_pts_per_side) * (1.0 - margin_y)
-    ctrl_pts_top = np.stack([ctrl_pts_x, ctrl_pts_y_top], axis=1)
-    ctrl_pts_bottom = np.stack([ctrl_pts_x, ctrl_pts_y_bottom], axis=1)
-    output_ctrl_pts_arr = np.concatenate(
-        [ctrl_pts_top, ctrl_pts_bottom], axis=0)
-    output_ctrl_pts = paddle.to_tensor(output_ctrl_pts_arr)
-    return output_ctrl_pts
-
-
-class TPSSpatialTransformer(nn.Layer):
-    def __init__(self,
-                 output_image_size=None,
-                 num_control_points=None,
-                 margins=None):
-        super(TPSSpatialTransformer, self).__init__()
-        self.output_image_size = output_image_size
-        self.num_control_points = num_control_points
-        self.margins = margins
-
-        self.target_height, self.target_width = output_image_size
-        target_control_points = build_output_control_points(num_control_points,
-                                                            margins)
-        N = num_control_points
-
-        # create padded kernel matrix
-        forward_kernel = paddle.zeros(shape=[N + 3, N + 3])
-        target_control_partial_repr = compute_partial_repr(
-            target_control_points, target_control_points)
-        target_control_partial_repr = paddle.cast(target_control_partial_repr,
-                                                  forward_kernel.dtype)
-        forward_kernel[:N, :N] = target_control_partial_repr
-        forward_kernel[:N, -3] = 1
-        forward_kernel[-3, :N] = 1
-        target_control_points = paddle.cast(target_control_points,
-                                            forward_kernel.dtype)
-        forward_kernel[:N, -2:] = target_control_points
-        forward_kernel[-2:, :N] = paddle.transpose(
-            target_control_points, perm=[1, 0])
-        # compute inverse matrix
-        inverse_kernel = paddle.inverse(forward_kernel)
-
-        # create target cordinate matrix
-        HW = self.target_height * self.target_width
-        target_coordinate = list(
-            itertools.product(
-                range(self.target_height), range(self.target_width)))
-        target_coordinate = paddle.to_tensor(target_coordinate)  # HW x 2
-        Y, X = paddle.split(
-            target_coordinate, target_coordinate.shape[1], axis=1)
-        Y = Y / (self.target_height - 1)
-        X = X / (self.target_width - 1)
-        target_coordinate = paddle.concat(
-            [X, Y], axis=1)  # convert from (y, x) to (x, y)
-        target_coordinate_partial_repr = compute_partial_repr(
-            target_coordinate, target_control_points)
-        target_coordinate_repr = paddle.concat(
-            [
-                target_coordinate_partial_repr, paddle.ones(shape=[HW, 1]),
-                target_coordinate
-            ],
-            axis=1)
-
-        # register precomputed matrices
-        self.inverse_kernel = inverse_kernel
-        self.padding_matrix = paddle.zeros(shape=[3, 2])
-        self.target_coordinate_repr = target_coordinate_repr
-        self.target_control_points = target_control_points
-
-    def forward(self, input, source_control_points):
-        assert source_control_points.ndimension() == 3
-        assert source_control_points.shape[1] == self.num_control_points
-        assert source_control_points.shape[2] == 2
-        batch_size = paddle.shape(source_control_points)[0]
-
-        self.padding_matrix = paddle.expand(
-            self.padding_matrix, shape=[batch_size, 3, 2])
-        Y = paddle.concat([source_control_points, self.padding_matrix], 1)
-        mapping_matrix = paddle.matmul(self.inverse_kernel, Y)
-        source_coordinate = paddle.matmul(self.target_coordinate_repr,
-                                          mapping_matrix)
-
-        grid = paddle.reshape(
-            source_coordinate,
-            shape=[-1, self.target_height, self.target_width, 2])
-        grid = paddle.clip(grid, 0,
-                           1)  # the source_control_points may be out of [0, 1].
-        # the input to grid_sample is normalized [-1, 1], but what we get is [0, 1]
-        grid = 2.0 * grid - 1.0
-        output_maps = grid_sample(input, grid, canvas=None)
-        return output_maps, source_coordinate

pyxlpr/ppocr/optimizer/__init__.py

@@ -1,61 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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 copy
-import paddle
-
-__all__ = ['build_optimizer']
-
-
-def build_lr_scheduler(lr_config, epochs, step_each_epoch):
-    from . import learning_rate
-    lr_config.update({'epochs': epochs, 'step_each_epoch': step_each_epoch})
-    if 'name' in lr_config:
-        lr_name = lr_config.pop('name')
-        lr = getattr(learning_rate, lr_name)(**lr_config)()
-    else:
-        lr = lr_config['learning_rate']
-    return lr
-
-
-def build_optimizer(config, epochs, step_each_epoch, parameters):
-    from . import regularizer, optimizer
-    config = copy.deepcopy(config)
-    # step1 build lr
-    lr = build_lr_scheduler(config.pop('lr'), epochs, step_each_epoch)
-
-    # step2 build regularization
-    if 'regularizer' in config and config['regularizer'] is not None:
-        reg_config = config.pop('regularizer')
-        reg_name = reg_config.pop('name') + 'Decay'
-        reg = getattr(regularizer, reg_name)(**reg_config)()
-    else:
-        reg = None
-
-    # step3 build optimizer
-    optim_name = config.pop('name')
-    if 'clip_norm' in config:
-        clip_norm = config.pop('clip_norm')
-        grad_clip = paddle.nn.ClipGradByNorm(clip_norm=clip_norm)
-    else:
-        grad_clip = None
-    optim = getattr(optimizer, optim_name)(learning_rate=lr,
-                                           weight_decay=reg,
-                                           grad_clip=grad_clip,
-                                           **config)
-    return optim(parameters), lr

pyxlpr/ppocr/optimizer/learning_rate.py

@@ -1,228 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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
-
-from paddle.optimizer import lr
-from .lr_scheduler import CyclicalCosineDecay
-
-
-class Linear(object):
-    """
-    Linear learning rate decay
-    Args:
-        lr (float): The initial learning rate. It is a python float number.
-        epochs(int): The decay step size. It determines the decay cycle.
-        end_lr(float, optional): The minimum final learning rate. Default: 0.0001.
-        power(float, optional): Power of polynomial. Default: 1.0.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 epochs,
-                 step_each_epoch,
-                 end_lr=0.0,
-                 power=1.0,
-                 warmup_epoch=0,
-                 last_epoch=-1,
-                 **kwargs):
-        super(Linear, self).__init__()
-        self.learning_rate = learning_rate
-        self.epochs = epochs * step_each_epoch
-        self.end_lr = end_lr
-        self.power = power
-        self.last_epoch = last_epoch
-        self.warmup_epoch = round(warmup_epoch * step_each_epoch)
-
-    def __call__(self):
-        learning_rate = lr.PolynomialDecay(
-            learning_rate=self.learning_rate,
-            decay_steps=self.epochs,
-            end_lr=self.end_lr,
-            power=self.power,
-            last_epoch=self.last_epoch)
-        if self.warmup_epoch > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_epoch,
-                start_lr=0.0,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
-        return learning_rate
-
-
-class Cosine(object):
-    """
-    Cosine learning rate decay
-    lr = 0.05 * (math.cos(epoch * (math.pi / epochs)) + 1)
-    Args:
-        lr(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        epochs(int): total training epochs
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 step_each_epoch,
-                 epochs,
-                 warmup_epoch=0,
-                 last_epoch=-1,
-                 **kwargs):
-        super(Cosine, self).__init__()
-        self.learning_rate = learning_rate
-        self.T_max = step_each_epoch * epochs
-        self.last_epoch = last_epoch
-        self.warmup_epoch = round(warmup_epoch * step_each_epoch)
-
-    def __call__(self):
-        learning_rate = lr.CosineAnnealingDecay(
-            learning_rate=self.learning_rate,
-            T_max=self.T_max,
-            last_epoch=self.last_epoch)
-        if self.warmup_epoch > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_epoch,
-                start_lr=0.0,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
-        return learning_rate
-
-
-class Step(object):
-    """
-    Piecewise learning rate decay
-    Args:
-        step_each_epoch(int): steps each epoch
-        learning_rate (float): The initial learning rate. It is a python float number.
-        step_size (int): the interval to update.
-        gamma (float, optional): The Ratio that the learning rate will be reduced. ``new_lr = origin_lr * gamma`` .
-            It should be less than 1.0. Default: 0.1.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 step_size,
-                 step_each_epoch,
-                 gamma,
-                 warmup_epoch=0,
-                 last_epoch=-1,
-                 **kwargs):
-        super(Step, self).__init__()
-        self.step_size = step_each_epoch * step_size
-        self.learning_rate = learning_rate
-        self.gamma = gamma
-        self.last_epoch = last_epoch
-        self.warmup_epoch = round(warmup_epoch * step_each_epoch)
-
-    def __call__(self):
-        learning_rate = lr.StepDecay(
-            learning_rate=self.learning_rate,
-            step_size=self.step_size,
-            gamma=self.gamma,
-            last_epoch=self.last_epoch)
-        if self.warmup_epoch > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_epoch,
-                start_lr=0.0,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
-        return learning_rate
-
-
-class Piecewise(object):
-    """
-    Piecewise learning rate decay
-    Args:
-        boundaries(list): A list of steps numbers. The type of element in the list is python int.
-        values(list): A list of learning rate values that will be picked during different epoch boundaries.
-            The type of element in the list is python float.
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
-
-    def __init__(self,
-                 step_each_epoch,
-                 decay_epochs,
-                 values,
-                 warmup_epoch=0,
-                 last_epoch=-1,
-                 **kwargs):
-        super(Piecewise, self).__init__()
-        self.boundaries = [step_each_epoch * e for e in decay_epochs]
-        self.values = values
-        self.last_epoch = last_epoch
-        self.warmup_epoch = round(warmup_epoch * step_each_epoch)
-
-    def __call__(self):
-        learning_rate = lr.PiecewiseDecay(
-            boundaries=self.boundaries,
-            values=self.values,
-            last_epoch=self.last_epoch)
-        if self.warmup_epoch > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_epoch,
-                start_lr=0.0,
-                end_lr=self.values[0],
-                last_epoch=self.last_epoch)
-        return learning_rate
-
-
-class CyclicalCosine(object):
-    """
-    Cyclical cosine learning rate decay
-    Args:
-        learning_rate(float): initial learning rate
-        step_each_epoch(int): steps each epoch
-        epochs(int): total training epochs
-        cycle(int): period of the cosine learning rate
-        last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 step_each_epoch,
-                 epochs,
-                 cycle,
-                 warmup_epoch=0,
-                 last_epoch=-1,
-                 **kwargs):
-        super(CyclicalCosine, self).__init__()
-        self.learning_rate = learning_rate
-        self.T_max = step_each_epoch * epochs
-        self.last_epoch = last_epoch
-        self.warmup_epoch = round(warmup_epoch * step_each_epoch)
-        self.cycle = round(cycle * step_each_epoch)
-
-    def __call__(self):
-        learning_rate = CyclicalCosineDecay(
-            learning_rate=self.learning_rate,
-            T_max=self.T_max,
-            cycle=self.cycle,
-            last_epoch=self.last_epoch)
-        if self.warmup_epoch > 0:
-            learning_rate = lr.LinearWarmup(
-                learning_rate=learning_rate,
-                warmup_steps=self.warmup_epoch,
-                start_lr=0.0,
-                end_lr=self.learning_rate,
-                last_epoch=self.last_epoch)
-        return learning_rate

pyxlpr/ppocr/optimizer/lr_scheduler.py

@@ -1,49 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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
-from paddle.optimizer.lr import LRScheduler
-
-
-class CyclicalCosineDecay(LRScheduler):
-    def __init__(self,
-                 learning_rate,
-                 T_max,
-                 cycle=1,
-                 last_epoch=-1,
-                 eta_min=0.0,
-                 verbose=False):
-        """
-        Cyclical cosine learning rate decay
-        A learning rate which can be referred in https://arxiv.org/pdf/2012.12645.pdf
-        Args:
-            learning rate(float): learning rate
-            T_max(int): maximum epoch num
-            cycle(int): period of the cosine decay
-            last_epoch (int, optional):  The index of last epoch. Can be set to restart training. Default: -1, means initial learning rate.
-            eta_min(float): minimum learning rate during training
-            verbose(bool): whether to print learning rate for each epoch
-        """
-        super(CyclicalCosineDecay, self).__init__(learning_rate, last_epoch,
-                                                  verbose)
-        self.cycle = cycle
-        self.eta_min = eta_min
-
-    def get_lr(self):
-        if self.last_epoch == 0:
-            return self.base_lr
-        reletive_epoch = self.last_epoch % self.cycle
-        lr = self.eta_min + 0.5 * (self.base_lr - self.eta_min) * \
-                (1 + math.cos(math.pi * reletive_epoch / self.cycle))
-        return lr

pyxlpr/ppocr/optimizer/optimizer.py

@@ -1,160 +0,0 @@
-# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
-#
-# 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
-
-from paddle import optimizer as optim
-
-
-class Momentum(object):
-    """
-    Simple Momentum optimizer with velocity state.
-    Args:
-        learning_rate (float|Variable) - The learning rate used to update parameters.
-            Can be a float value or a Variable with one float value as data element.
-        momentum (float) - Momentum factor.
-        regularization (WeightDecayRegularizer, optional) - The strategy of regularization.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 momentum,
-                 weight_decay=None,
-                 grad_clip=None,
-                 **args):
-        super(Momentum, self).__init__()
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.weight_decay = weight_decay
-        self.grad_clip = grad_clip
-
-    def __call__(self, parameters):
-        opt = optim.Momentum(
-            learning_rate=self.learning_rate,
-            momentum=self.momentum,
-            weight_decay=self.weight_decay,
-            grad_clip=self.grad_clip,
-            parameters=parameters)
-        return opt
-
-
-class Adam(object):
-    def __init__(self,
-                 learning_rate=0.001,
-                 beta1=0.9,
-                 beta2=0.999,
-                 epsilon=1e-08,
-                 parameter_list=None,
-                 weight_decay=None,
-                 grad_clip=None,
-                 name=None,
-                 lazy_mode=False,
-                 **kwargs):
-        self.learning_rate = learning_rate
-        self.beta1 = beta1
-        self.beta2 = beta2
-        self.epsilon = epsilon
-        self.parameter_list = parameter_list
-        self.learning_rate = learning_rate
-        self.weight_decay = weight_decay
-        self.grad_clip = grad_clip
-        self.name = name
-        self.lazy_mode = lazy_mode
-
-    def __call__(self, parameters):
-        opt = optim.Adam(
-            learning_rate=self.learning_rate,
-            beta1=self.beta1,
-            beta2=self.beta2,
-            epsilon=self.epsilon,
-            weight_decay=self.weight_decay,
-            grad_clip=self.grad_clip,
-            name=self.name,
-            lazy_mode=self.lazy_mode,
-            parameters=parameters)
-        return opt
-
-
-class RMSProp(object):
-    """
-    Root Mean Squared Propagation (RMSProp) is an unpublished, adaptive learning rate method.
-    Args:
-        learning_rate (float|Variable) - The learning rate used to update parameters.
-            Can be a float value or a Variable with one float value as data element.
-        momentum (float) - Momentum factor.
-        rho (float) - rho value in equation.
-        epsilon (float) - avoid division by zero, default is 1e-6.
-        regularization (WeightDecayRegularizer, optional) - The strategy of regularization.
-    """
-
-    def __init__(self,
-                 learning_rate,
-                 momentum=0.0,
-                 rho=0.95,
-                 epsilon=1e-6,
-                 weight_decay=None,
-                 grad_clip=None,
-                 **args):
-        super(RMSProp, self).__init__()
-        self.learning_rate = learning_rate
-        self.momentum = momentum
-        self.rho = rho
-        self.epsilon = epsilon
-        self.weight_decay = weight_decay
-        self.grad_clip = grad_clip
-
-    def __call__(self, parameters):
-        opt = optim.RMSProp(
-            learning_rate=self.learning_rate,
-            momentum=self.momentum,
-            rho=self.rho,
-            epsilon=self.epsilon,
-            weight_decay=self.weight_decay,
-            grad_clip=self.grad_clip,
-            parameters=parameters)
-        return opt
-
-
-class Adadelta(object):
-    def __init__(self,
-                 learning_rate=0.001,
-                 epsilon=1e-08,
-                 rho=0.95,
-                 parameter_list=None,
-                 weight_decay=None,
-                 grad_clip=None,
-                 name=None,
-                 **kwargs):
-        self.learning_rate = learning_rate
-        self.epsilon = epsilon
-        self.rho = rho
-        self.parameter_list = parameter_list
-        self.learning_rate = learning_rate
-        self.weight_decay = weight_decay
-        self.grad_clip = grad_clip
-        self.name = name
-
-    def __call__(self, parameters):
-        opt = optim.Adadelta(
-            learning_rate=self.learning_rate,
-            epsilon=self.epsilon,
-            rho=self.rho,
-            weight_decay=self.weight_decay,
-            grad_clip=self.grad_clip,
-            name=self.name,
-            parameters=parameters)
-        return opt