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

pyxlpr/ppocr/modeling/backbones/e2e_resnet_vd_pg.py

@@ -1,265 +0,0 @@
-# copyright (c) 2021 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=2, stride=2, padding=0, ceil_mode=True)
-        self._conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=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):
-        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=False if if_first else True,
-                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=1,
-                is_vd_mode=False if if_first else True,
-                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]
-            depth = [3, 4, 6, 3, 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,
-                        2048] if layers >= 50 else [64, 64, 128, 256]
-        num_filters = [64, 128, 256, 512, 512]
-
-        self.conv1_1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=64,
-            kernel_size=7,
-            stride=2,
-            act='relu',
-            name="conv1_1")
-        self.pool2d_max = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
-
-        self.stages = []
-        self.out_channels = [3, 64]
-        # num_filters = [64, 128, 256, 512, 512]
-        if layers >= 50:
-            for block in range(len(depth)):
-                block_list = []
-                shortcut = False
-                for i in range(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)
-                    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=2 if i == 0 and block != 0 else 1,
-                            shortcut=shortcut,
-                            if_first=block == i == 0,
-                            name=conv_name))
-                    shortcut = True
-                    block_list.append(bottleneck_block)
-                self.out_channels.append(num_filters[block] * 4)
-                self.stages.append(nn.Sequential(*block_list))
-        else:
-            for block in range(len(depth)):
-                block_list = []
-                shortcut = False
-                for i in range(depth[block]):
-                    conv_name = "res" + str(block + 2) + chr(97 + i)
-                    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=2 if i == 0 and block != 0 else 1,
-                            shortcut=shortcut,
-                            if_first=block == i == 0,
-                            name=conv_name))
-                    shortcut = True
-                    block_list.append(basic_block)
-                self.out_channels.append(num_filters[block])
-                self.stages.append(nn.Sequential(*block_list))
-
-    def forward(self, inputs):
-        out = [inputs]
-        y = self.conv1_1(inputs)
-        out.append(y)
-        y = self.pool2d_max(y)
-        for block in self.stages:
-            y = block(y)
-            out.append(y)
-        return out

pyxlpr/ppocr/modeling/backbones/kie_unet_sdmgr.py

@@ -1,186 +0,0 @@
-# copyright (c) 2021 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 nn
-import numpy as np
-import cv2
-
-__all__ = ["Kie_backbone"]
-
-
-class Encoder(nn.Layer):
-    def __init__(self, num_channels, num_filters):
-        super(Encoder, self).__init__()
-        self.conv1 = nn.Conv2D(
-            num_channels,
-            num_filters,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias_attr=False)
-        self.bn1 = nn.BatchNorm(num_filters, act='relu')
-
-        self.conv2 = nn.Conv2D(
-            num_filters,
-            num_filters,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias_attr=False)
-        self.bn2 = nn.BatchNorm(num_filters, act='relu')
-
-        self.pool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)
-
-    def forward(self, inputs):
-        x = self.conv1(inputs)
-        x = self.bn1(x)
-        x = self.conv2(x)
-        x = self.bn2(x)
-        x_pooled = self.pool(x)
-        return x, x_pooled
-
-
-class Decoder(nn.Layer):
-    def __init__(self, num_channels, num_filters):
-        super(Decoder, self).__init__()
-
-        self.conv1 = nn.Conv2D(
-            num_channels,
-            num_filters,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias_attr=False)
-        self.bn1 = nn.BatchNorm(num_filters, act='relu')
-
-        self.conv2 = nn.Conv2D(
-            num_filters,
-            num_filters,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            bias_attr=False)
-        self.bn2 = nn.BatchNorm(num_filters, act='relu')
-
-        self.conv0 = nn.Conv2D(
-            num_channels,
-            num_filters,
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            bias_attr=False)
-        self.bn0 = nn.BatchNorm(num_filters, act='relu')
-
-    def forward(self, inputs_prev, inputs):
-        x = self.conv0(inputs)
-        x = self.bn0(x)
-        x = paddle.nn.functional.interpolate(
-            x, scale_factor=2, mode='bilinear', align_corners=False)
-        x = paddle.concat([inputs_prev, x], axis=1)
-        x = self.conv1(x)
-        x = self.bn1(x)
-        x = self.conv2(x)
-        x = self.bn2(x)
-        return x
-
-
-class UNet(nn.Layer):
-    def __init__(self):
-        super(UNet, self).__init__()
-        self.down1 = Encoder(num_channels=3, num_filters=16)
-        self.down2 = Encoder(num_channels=16, num_filters=32)
-        self.down3 = Encoder(num_channels=32, num_filters=64)
-        self.down4 = Encoder(num_channels=64, num_filters=128)
-        self.down5 = Encoder(num_channels=128, num_filters=256)
-
-        self.up1 = Decoder(32, 16)
-        self.up2 = Decoder(64, 32)
-        self.up3 = Decoder(128, 64)
-        self.up4 = Decoder(256, 128)
-        self.out_channels = 16
-
-    def forward(self, inputs):
-        x1, _ = self.down1(inputs)
-        _, x2 = self.down2(x1)
-        _, x3 = self.down3(x2)
-        _, x4 = self.down4(x3)
-        _, x5 = self.down5(x4)
-
-        x = self.up4(x4, x5)
-        x = self.up3(x3, x)
-        x = self.up2(x2, x)
-        x = self.up1(x1, x)
-        return x
-
-
-class Kie_backbone(nn.Layer):
-    def __init__(self, in_channels, **kwargs):
-        super(Kie_backbone, self).__init__()
-        self.out_channels = 16
-        self.img_feat = UNet()
-        self.maxpool = nn.MaxPool2D(kernel_size=7)
-
-    def bbox2roi(self, bbox_list):
-        rois_list = []
-        rois_num = []
-        for img_id, bboxes in enumerate(bbox_list):
-            rois_num.append(bboxes.shape[0])
-            rois_list.append(bboxes)
-        rois = paddle.concat(rois_list, 0)
-        rois_num = paddle.to_tensor(rois_num, dtype='int32')
-        return rois, rois_num
-
-    def pre_process(self, img, relations, texts, gt_bboxes, tag, img_size):
-        img, relations, texts, gt_bboxes, tag, img_size = img.numpy(
-        ), relations.numpy(), texts.numpy(), gt_bboxes.numpy(), tag.numpy(
-        ).tolist(), img_size.numpy()
-        temp_relations, temp_texts, temp_gt_bboxes = [], [], []
-        h, w = int(np.max(img_size[:, 0])), int(np.max(img_size[:, 1]))
-        img = paddle.to_tensor(img[:, :, :h, :w])
-        batch = len(tag)
-        for i in range(batch):
-            num, recoder_len = tag[i][0], tag[i][1]
-            temp_relations.append(
-                paddle.to_tensor(
-                    relations[i, :num, :num, :], dtype='float32'))
-            temp_texts.append(
-                paddle.to_tensor(
-                    texts[i, :num, :recoder_len], dtype='float32'))
-            temp_gt_bboxes.append(
-                paddle.to_tensor(
-                    gt_bboxes[i, :num, ...], dtype='float32'))
-        return img, temp_relations, temp_texts, temp_gt_bboxes
-
-    def forward(self, inputs):
-        img = inputs[0]
-        relations, texts, gt_bboxes, tag, img_size = inputs[1], inputs[
-            2], inputs[3], inputs[5], inputs[-1]
-        img, relations, texts, gt_bboxes = self.pre_process(
-            img, relations, texts, gt_bboxes, tag, img_size)
-        x = self.img_feat(img)
-        boxes, rois_num = self.bbox2roi(gt_bboxes)
-        feats = paddle.fluid.layers.roi_align(
-            x,
-            boxes,
-            spatial_scale=1.0,
-            pooled_height=7,
-            pooled_width=7,
-            rois_num=rois_num)
-        feats = self.maxpool(feats).squeeze(-1).squeeze(-1)
-        return [relations, texts, feats]

pyxlpr/ppocr/modeling/backbones/rec_mobilenet_v3.py

@@ -1,138 +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 paddle import nn
-
-from pyxlpr.ppocr.modeling.backbones.det_mobilenet_v3 import ResidualUnit, ConvBNLayer, make_divisible
-
-__all__ = ['MobileNetV3']
-
-
-class MobileNetV3(nn.Layer):
-    def __init__(self,
-                 in_channels=3,
-                 model_name='small',
-                 scale=0.5,
-                 large_stride=None,
-                 small_stride=None,
-                 disable_se=False,
-                 **kwargs):
-        super(MobileNetV3, self).__init__()
-        self.disable_se = disable_se
-        if small_stride is None:
-            small_stride = [2, 2, 2, 2]
-        if large_stride is None:
-            large_stride = [1, 2, 2, 2]
-
-        assert isinstance(large_stride, list), "large_stride type must " \
-                                               "be list but got {}".format(type(large_stride))
-        assert isinstance(small_stride, list), "small_stride type must " \
-                                               "be list but got {}".format(type(small_stride))
-        assert len(large_stride) == 4, "large_stride length must be " \
-                                       "4 but got {}".format(len(large_stride))
-        assert len(small_stride) == 4, "small_stride length must be " \
-                                       "4 but got {}".format(len(small_stride))
-
-        if model_name == "large":
-            cfg = [
-                # k, exp, c,  se,     nl,  s,
-                [3, 16, 16, False, 'relu', large_stride[0]],
-                [3, 64, 24, False, 'relu', (large_stride[1], 1)],
-                [3, 72, 24, False, 'relu', 1],
-                [5, 72, 40, True, 'relu', (large_stride[2], 1)],
-                [5, 120, 40, True, 'relu', 1],
-                [5, 120, 40, True, 'relu', 1],
-                [3, 240, 80, False, 'hardswish', 1],
-                [3, 200, 80, False, 'hardswish', 1],
-                [3, 184, 80, False, 'hardswish', 1],
-                [3, 184, 80, False, 'hardswish', 1],
-                [3, 480, 112, True, 'hardswish', 1],
-                [3, 672, 112, True, 'hardswish', 1],
-                [5, 672, 160, True, 'hardswish', (large_stride[3], 1)],
-                [5, 960, 160, True, 'hardswish', 1],
-                [5, 960, 160, True, 'hardswish', 1],
-            ]
-            cls_ch_squeeze = 960
-        elif model_name == "small":
-            cfg = [
-                # k, exp, c,  se,     nl,  s,
-                [3, 16, 16, True, 'relu', (small_stride[0], 1)],
-                [3, 72, 24, False, 'relu', (small_stride[1], 1)],
-                [3, 88, 24, False, 'relu', 1],
-                [5, 96, 40, True, 'hardswish', (small_stride[2], 1)],
-                [5, 240, 40, True, 'hardswish', 1],
-                [5, 240, 40, True, 'hardswish', 1],
-                [5, 120, 48, True, 'hardswish', 1],
-                [5, 144, 48, True, 'hardswish', 1],
-                [5, 288, 96, True, 'hardswish', (small_stride[3], 1)],
-                [5, 576, 96, True, 'hardswish', 1],
-                [5, 576, 96, True, 'hardswish', 1],
-            ]
-            cls_ch_squeeze = 576
-        else:
-            raise NotImplementedError("mode[" + model_name +
-                                      "_model] is not implemented!")
-
-        supported_scale = [0.35, 0.5, 0.75, 1.0, 1.25]
-        assert scale in supported_scale, \
-            "supported scales are {} but input scale is {}".format(supported_scale, scale)
-
-        inplanes = 16
-        # conv1
-        self.conv1 = ConvBNLayer(
-            in_channels=in_channels,
-            out_channels=make_divisible(inplanes * scale),
-            kernel_size=3,
-            stride=2,
-            padding=1,
-            groups=1,
-            if_act=True,
-            act='hardswish')
-        i = 0
-        block_list = []
-        inplanes = make_divisible(inplanes * scale)
-        for (k, exp, c, se, nl, s) in cfg:
-            se = se and not self.disable_se
-            block_list.append(
-                ResidualUnit(
-                    in_channels=inplanes,
-                    mid_channels=make_divisible(scale * exp),
-                    out_channels=make_divisible(scale * c),
-                    kernel_size=k,
-                    stride=s,
-                    use_se=se,
-                    act=nl))
-            inplanes = make_divisible(scale * c)
-            i += 1
-        self.blocks = nn.Sequential(*block_list)
-
-        self.conv2 = ConvBNLayer(
-            in_channels=inplanes,
-            out_channels=make_divisible(scale * cls_ch_squeeze),
-            kernel_size=1,
-            stride=1,
-            padding=0,
-            groups=1,
-            if_act=True,
-            act='hardswish')
-
-        self.pool = nn.MaxPool2D(kernel_size=2, stride=2, padding=0)
-        self.out_channels = make_divisible(scale * cls_ch_squeeze)
-
-    def forward(self, x):
-        x = self.conv1(x)
-        x = self.blocks(x)
-        x = self.conv2(x)
-        x = self.pool(x)
-        return x