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

pyxlpr/ppocr/modeling/backbones/rec_resnet_fpn.py

@@ -1,307 +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 paddle import nn, ParamAttr
-from paddle.nn import functional as F
-import paddle.fluid as fluid
-import paddle
-import numpy as np
-
-__all__ = ["ResNetFPN"]
-
-
-class ResNetFPN(nn.Layer):
-    def __init__(self, in_channels=1, layers=50, **kwargs):
-        super(ResNetFPN, self).__init__()
-        supported_layers = {
-            18: {
-                'depth': [2, 2, 2, 2],
-                'block_class': BasicBlock
-            },
-            34: {
-                'depth': [3, 4, 6, 3],
-                'block_class': BasicBlock
-            },
-            50: {
-                'depth': [3, 4, 6, 3],
-                'block_class': BottleneckBlock
-            },
-            101: {
-                'depth': [3, 4, 23, 3],
-                'block_class': BottleneckBlock
-            },
-            152: {
-                'depth': [3, 8, 36, 3],
-                'block_class': BottleneckBlock
-            }
-        }
-        stride_list = [(2, 2), (2, 2), (1, 1), (1, 1)]
-        num_filters = [64, 128, 256, 512]
-        self.depth = supported_layers[layers]['depth']
-        self.F = []
-        self.conv = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=64,
-            kernel_size=7,
-            stride=2,
-            act="relu",
-            name="conv1")
-        self.block_list = []
-        in_ch = 64
-        if layers >= 50:
-            for block in range(len(self.depth)):
-                for i in range(self.depth[block]):
-                    if layers in [101, 152] and block == 2:
-                        if i == 0:
-                            conv_name = "res" + str(block + 2) + "a"
-                        else:
-                            conv_name = "res" + str(block + 2) + "b" + str(i)
-                    else:
-                        conv_name = "res" + str(block + 2) + chr(97 + i)
-                    block_list = self.add_sublayer(
-                        "bottleneckBlock_{}_{}".format(block, i),
-                        BottleneckBlock(
-                            in_channels=in_ch,
-                            out_channels=num_filters[block],
-                            stride=stride_list[block] if i == 0 else 1,
-                            name=conv_name))
-                    in_ch = num_filters[block] * 4
-                    self.block_list.append(block_list)
-                self.F.append(block_list)
-        else:
-            for block in range(len(self.depth)):
-                for i in range(self.depth[block]):
-                    conv_name = "res" + str(block + 2) + chr(97 + i)
-                    if i == 0 and block != 0:
-                        stride = (2, 1)
-                    else:
-                        stride = (1, 1)
-                    basic_block = self.add_sublayer(
-                        conv_name,
-                        BasicBlock(
-                            in_channels=in_ch,
-                            out_channels=num_filters[block],
-                            stride=stride_list[block] if i == 0 else 1,
-                            is_first=block == i == 0,
-                            name=conv_name))
-                    in_ch = basic_block.out_channels
-                    self.block_list.append(basic_block)
-        out_ch_list = [in_ch // 4, in_ch // 2, in_ch]
-        self.base_block = []
-        self.conv_trans = []
-        self.bn_block = []
-        for i in [-2, -3]:
-            in_channels = out_ch_list[i + 1] + out_ch_list[i]
-
-            self.base_block.append(
-                self.add_sublayer(
-                    "F_{}_base_block_0".format(i),
-                    nn.Conv2D(
-                        in_channels=in_channels,
-                        out_channels=out_ch_list[i],
-                        kernel_size=1,
-                        weight_attr=ParamAttr(trainable=True),
-                        bias_attr=ParamAttr(trainable=True))))
-            self.base_block.append(
-                self.add_sublayer(
-                    "F_{}_base_block_1".format(i),
-                    nn.Conv2D(
-                        in_channels=out_ch_list[i],
-                        out_channels=out_ch_list[i],
-                        kernel_size=3,
-                        padding=1,
-                        weight_attr=ParamAttr(trainable=True),
-                        bias_attr=ParamAttr(trainable=True))))
-            self.base_block.append(
-                self.add_sublayer(
-                    "F_{}_base_block_2".format(i),
-                    nn.BatchNorm(
-                        num_channels=out_ch_list[i],
-                        act="relu",
-                        param_attr=ParamAttr(trainable=True),
-                        bias_attr=ParamAttr(trainable=True))))
-        self.base_block.append(
-            self.add_sublayer(
-                "F_{}_base_block_3".format(i),
-                nn.Conv2D(
-                    in_channels=out_ch_list[i],
-                    out_channels=512,
-                    kernel_size=1,
-                    bias_attr=ParamAttr(trainable=True),
-                    weight_attr=ParamAttr(trainable=True))))
-        self.out_channels = 512
-
-    def __call__(self, x):
-        x = self.conv(x)
-        fpn_list = []
-        F = []
-        for i in range(len(self.depth)):
-            fpn_list.append(np.sum(self.depth[:i + 1]))
-
-        for i, block in enumerate(self.block_list):
-            x = block(x)
-            for number in fpn_list:
-                if i + 1 == number:
-                    F.append(x)
-        base = F[-1]
-
-        j = 0
-        for i, block in enumerate(self.base_block):
-            if i % 3 == 0 and i < 6:
-                j = j + 1
-                b, c, w, h = F[-j - 1].shape
-                if [w, h] == list(base.shape[2:]):
-                    base = base
-                else:
-                    base = self.conv_trans[j - 1](base)
-                    base = self.bn_block[j - 1](base)
-                base = paddle.concat([base, F[-j - 1]], axis=1)
-            base = block(base)
-        return base
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride=1,
-                 groups=1,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-        self.conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=2 if stride == (1, 1) else kernel_size,
-            dilation=2 if stride == (1, 1) else 1,
-            stride=stride,
-            padding=(kernel_size - 1) // 2,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '.conv2d.output.1.w_0'),
-            bias_attr=False, )
-
-        if name == "conv1":
-            bn_name = "bn_" + name
-        else:
-            bn_name = "bn" + name[3:]
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name=name + '.output.1.w_0'),
-            bias_attr=ParamAttr(name=name + '.output.1.b_0'),
-            moving_mean_name=bn_name + "_mean",
-            moving_variance_name=bn_name + "_variance")
-
-    def __call__(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class ShortCut(nn.Layer):
-    def __init__(self, in_channels, out_channels, stride, name, is_first=False):
-        super(ShortCut, self).__init__()
-        self.use_conv = True
-
-        if in_channels != out_channels or stride != 1 or is_first == True:
-            if stride == (1, 1):
-                self.conv = ConvBNLayer(
-                    in_channels, out_channels, 1, 1, name=name)
-            else:  # stride==(2,2)
-                self.conv = ConvBNLayer(
-                    in_channels, out_channels, 1, stride, name=name)
-        else:
-            self.use_conv = False
-
-    def forward(self, x):
-        if self.use_conv:
-            x = self.conv(x)
-        return x
-
-
-class BottleneckBlock(nn.Layer):
-    def __init__(self, in_channels, out_channels, stride, name):
-        super(BottleneckBlock, self).__init__()
-        self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=1,
-            act='relu',
-            name=name + "_branch2a")
-        self.conv1 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            stride=stride,
-            act='relu',
-            name=name + "_branch2b")
-
-        self.conv2 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels * 4,
-            kernel_size=1,
-            act=None,
-            name=name + "_branch2c")
-
-        self.short = ShortCut(
-            in_channels=in_channels,
-            out_channels=out_channels * 4,
-            stride=stride,
-            is_first=False,
-            name=name + "_branch1")
-        self.out_channels = out_channels * 4
-
-    def forward(self, x):
-        y = self.conv0(x)
-        y = self.conv1(y)
-        y = self.conv2(y)
-        y = y + self.short(x)
-        y = F.relu(y)
-        return y
-
-
-class BasicBlock(nn.Layer):
-    def __init__(self, in_channels, out_channels, stride, name, is_first):
-        super(BasicBlock, self).__init__()
-        self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            act='relu',
-            stride=stride,
-            name=name + "_branch2a")
-        self.conv1 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            act=None,
-            name=name + "_branch2b")
-        self.short = ShortCut(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            stride=stride,
-            is_first=is_first,
-            name=name + "_branch1")
-        self.out_channels = out_channels
-
-    def forward(self, x):
-        y = self.conv0(x)
-        y = self.conv1(y)
-        y = y + self.short(x)
-        return F.relu(y)

pyxlpr/ppocr/modeling/backbones/rec_resnet_vd.py

@@ -1,286 +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
-
-import paddle
-from paddle import ParamAttr
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-__all__ = ["ResNet"]
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(
-            self,
-            in_channels,
-            out_channels,
-            kernel_size,
-            stride=1,
-            groups=1,
-            is_vd_mode=False,
-            act=None,
-            name=None, ):
-        super(ConvBNLayer, self).__init__()
-
-        self.is_vd_mode = is_vd_mode
-        self._pool2d_avg = nn.AvgPool2D(
-            kernel_size=stride, stride=stride, padding=0, ceil_mode=True)
-        self._conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=1 if is_vd_mode else stride,
-            padding=(kernel_size - 1) // 2,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + "_weights"),
-            bias_attr=False)
-        if name == "conv1":
-            bn_name = "bn_" + name
-        else:
-            bn_name = "bn" + name[3:]
-        self._batch_norm = nn.BatchNorm(
-            out_channels,
-            act=act,
-            param_attr=ParamAttr(name=bn_name + '_scale'),
-            bias_attr=ParamAttr(bn_name + '_offset'),
-            moving_mean_name=bn_name + '_mean',
-            moving_variance_name=bn_name + '_variance')
-
-    def forward(self, inputs):
-        if self.is_vd_mode:
-            inputs = self._pool2d_avg(inputs)
-        y = self._conv(inputs)
-        y = self._batch_norm(y)
-        return y
-
-
-class BottleneckBlock(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 stride,
-                 shortcut=True,
-                 if_first=False,
-                 name=None):
-        super(BottleneckBlock, self).__init__()
-
-        self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=1,
-            act='relu',
-            name=name + "_branch2a")
-        self.conv1 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            stride=stride,
-            act='relu',
-            name=name + "_branch2b")
-        self.conv2 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels * 4,
-            kernel_size=1,
-            act=None,
-            name=name + "_branch2c")
-
-        if not shortcut:
-            self.short = ConvBNLayer(
-                in_channels=in_channels,
-                out_channels=out_channels * 4,
-                kernel_size=1,
-                stride=stride,
-                is_vd_mode=not if_first and stride[0] != 1,
-                name=name + "_branch1")
-
-        self.shortcut = shortcut
-
-    def forward(self, inputs):
-        y = self.conv0(inputs)
-
-        conv1 = self.conv1(y)
-        conv2 = self.conv2(conv1)
-
-        if self.shortcut:
-            short = inputs
-        else:
-            short = self.short(inputs)
-        y = paddle.add(x=short, y=conv2)
-        y = F.relu(y)
-        return y
-
-
-class BasicBlock(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 stride,
-                 shortcut=True,
-                 if_first=False,
-                 name=None):
-        super(BasicBlock, self).__init__()
-        self.stride = stride
-        self.conv0 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            stride=stride,
-            act='relu',
-            name=name + "_branch2a")
-        self.conv1 = ConvBNLayer(
-            in_channels=out_channels,
-            out_channels=out_channels,
-            kernel_size=3,
-            act=None,
-            name=name + "_branch2b")
-
-        if not shortcut:
-            self.short = ConvBNLayer(
-                in_channels=in_channels,
-                out_channels=out_channels,
-                kernel_size=1,
-                stride=stride,
-                is_vd_mode=not if_first and stride[0] != 1,
-                name=name + "_branch1")
-
-        self.shortcut = shortcut
-
-    def forward(self, inputs):
-        y = self.conv0(inputs)
-        conv1 = self.conv1(y)
-
-        if self.shortcut:
-            short = inputs
-        else:
-            short = self.short(inputs)
-        y = paddle.add(x=short, y=conv1)
-        y = F.relu(y)
-        return y
-
-
-class ResNet(nn.Layer):
-    def __init__(self, in_channels=3, layers=50, **kwargs):
-        super(ResNet, self).__init__()
-
-        self.layers = layers
-        supported_layers = [18, 34, 50, 101, 152, 200]
-        assert layers in supported_layers, \
-            "supported layers are {} but input layer is {}".format(
-                supported_layers, layers)
-
-        if layers == 18:
-            depth = [2, 2, 2, 2]
-        elif layers == 34 or layers == 50:
-            depth = [3, 4, 6, 3]
-        elif layers == 101:
-            depth = [3, 4, 23, 3]
-        elif layers == 152:
-            depth = [3, 8, 36, 3]
-        elif layers == 200:
-            depth = [3, 12, 48, 3]
-        num_channels = [64, 256, 512,
-                        1024] if layers >= 50 else [64, 64, 128, 256]
-        num_filters = [64, 128, 256, 512]
-
-        self.conv1_1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=32,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv1_1")
-        self.conv1_2 = ConvBNLayer(
-            in_channels=32,
-            out_channels=32,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv1_2")
-        self.conv1_3 = ConvBNLayer(
-            in_channels=32,
-            out_channels=64,
-            kernel_size=3,
-            stride=1,
-            act='relu',
-            name="conv1_3")
-        self.pool2d_max = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
-
-        self.block_list = []
-        if layers >= 50:
-            for block in range(len(depth)):
-                shortcut = False
-                for i in range(depth[block]):
-                    if layers in [101, 152, 200] and block == 2:
-                        if i == 0:
-                            conv_name = "res" + str(block + 2) + "a"
-                        else:
-                            conv_name = "res" + str(block + 2) + "b" + str(i)
-                    else:
-                        conv_name = "res" + str(block + 2) + chr(97 + i)
-
-                    if i == 0 and block != 0:
-                        stride = (2, 1)
-                    else:
-                        stride = (1, 1)
-                    bottleneck_block = self.add_sublayer(
-                        'bb_%d_%d' % (block, i),
-                        BottleneckBlock(
-                            in_channels=num_channels[block]
-                            if i == 0 else num_filters[block] * 4,
-                            out_channels=num_filters[block],
-                            stride=stride,
-                            shortcut=shortcut,
-                            if_first=block == i == 0,
-                            name=conv_name))
-                    shortcut = True
-                    self.block_list.append(bottleneck_block)
-                self.out_channels = num_filters[block] * 4
-        else:
-            for block in range(len(depth)):
-                shortcut = False
-                for i in range(depth[block]):
-                    conv_name = "res" + str(block + 2) + chr(97 + i)
-                    if i == 0 and block != 0:
-                        stride = (2, 1)
-                    else:
-                        stride = (1, 1)
-
-                    basic_block = self.add_sublayer(
-                        'bb_%d_%d' % (block, i),
-                        BasicBlock(
-                            in_channels=num_channels[block]
-                            if i == 0 else num_filters[block],
-                            out_channels=num_filters[block],
-                            stride=stride,
-                            shortcut=shortcut,
-                            if_first=block == i == 0,
-                            name=conv_name))
-                    shortcut = True
-                    self.block_list.append(basic_block)
-                self.out_channels = num_filters[block]
-        self.out_pool = nn.MaxPool2D(kernel_size=2, stride=2, padding=0)
-
-    def forward(self, inputs):
-        y = self.conv1_1(inputs)
-        y = self.conv1_2(y)
-        y = self.conv1_3(y)
-        y = self.pool2d_max(y)
-        for block in self.block_list:
-            y = block(y)
-        y = self.out_pool(y)
-        return y

pyxlpr/ppocr/modeling/heads/__init__.py

@@ -1,54 +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.
-
-__all__ = ['build_head']
-
-
-def build_head(config):
-    # det head
-    from .det_db_head import DBHead
-    from .det_east_head import EASTHead
-    from .det_sast_head import SASTHead
-    from .det_pse_head import PSEHead
-    from .e2e_pg_head import PGHead
-
-    # rec head
-    from .rec_ctc_head import CTCHead
-    from .rec_att_head import AttentionHead
-    from .rec_srn_head import SRNHead
-    from .rec_nrtr_head import Transformer
-    from .rec_sar_head import SARHead
-    from .rec_aster_head import AsterHead
-
-    # cls head
-    from .cls_head import ClsHead
-
-    #kie head
-    from .kie_sdmgr_head import SDMGRHead
-
-    from .table_att_head import TableAttentionHead
-
-    support_dict = [
-        'DBHead', 'PSEHead', 'EASTHead', 'SASTHead', 'CTCHead', 'ClsHead',
-        'AttentionHead', 'SRNHead', 'PGHead', 'Transformer',
-        'TableAttentionHead', 'SARHead', 'AsterHead', 'SDMGRHead'
-    ]
-
-    #table head
-
-    module_name = config.pop('name')
-    assert module_name in support_dict, Exception('head only support {}'.format(
-        support_dict))
-    module_class = eval(module_name)(**config)
-    return module_class

pyxlpr/ppocr/modeling/heads/cls_head.py

@@ -1,52 +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
-
-import math
-import paddle
-from paddle import nn, ParamAttr
-import paddle.nn.functional as F
-
-
-class ClsHead(nn.Layer):
-    """
-    Class orientation
-
-    Args:
-
-        params(dict): super parameters for build Class network
-    """
-
-    def __init__(self, in_channels, class_dim, **kwargs):
-        super(ClsHead, self).__init__()
-        self.pool = nn.AdaptiveAvgPool2D(1)
-        stdv = 1.0 / math.sqrt(in_channels * 1.0)
-        self.fc = nn.Linear(
-            in_channels,
-            class_dim,
-            weight_attr=ParamAttr(
-                name="fc_0.w_0",
-                initializer=nn.initializer.Uniform(-stdv, stdv)),
-            bias_attr=ParamAttr(name="fc_0.b_0"), )
-
-    def forward(self, x, targets=None):
-        x = self.pool(x)
-        x = paddle.reshape(x, shape=[x.shape[0], x.shape[1]])
-        x = self.fc(x)
-        if not self.training:
-            x = F.softmax(x, axis=1)
-        return x