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

pyxlpr/ppocr/modeling/necks/db_fpn.py

@@ -1,111 +0,0 @@
-# copyright (c) 2019 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 paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class DBFPN(nn.Layer):
-    def __init__(self, in_channels, out_channels, **kwargs):
-        super(DBFPN, self).__init__()
-        self.out_channels = out_channels
-        weight_attr = paddle.nn.initializer.KaimingUniform()
-
-        self.in2_conv = nn.Conv2D(
-            in_channels=in_channels[0],
-            out_channels=self.out_channels,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.in3_conv = nn.Conv2D(
-            in_channels=in_channels[1],
-            out_channels=self.out_channels,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.in4_conv = nn.Conv2D(
-            in_channels=in_channels[2],
-            out_channels=self.out_channels,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.in5_conv = nn.Conv2D(
-            in_channels=in_channels[3],
-            out_channels=self.out_channels,
-            kernel_size=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.p5_conv = nn.Conv2D(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels // 4,
-            kernel_size=3,
-            padding=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.p4_conv = nn.Conv2D(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels // 4,
-            kernel_size=3,
-            padding=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.p3_conv = nn.Conv2D(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels // 4,
-            kernel_size=3,
-            padding=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-        self.p2_conv = nn.Conv2D(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels // 4,
-            kernel_size=3,
-            padding=1,
-            weight_attr=ParamAttr(initializer=weight_attr),
-            bias_attr=False)
-
-    def forward(self, x):
-        c2, c3, c4, c5 = x
-
-        in5 = self.in5_conv(c5)
-        in4 = self.in4_conv(c4)
-        in3 = self.in3_conv(c3)
-        in2 = self.in2_conv(c2)
-
-        # 特征上采样
-        out4 = in4 + F.upsample(
-            in5, scale_factor=2, mode="nearest", align_mode=1)  # 1/16
-        out3 = in3 + F.upsample(
-            out4, scale_factor=2, mode="nearest", align_mode=1)  # 1/8
-        out2 = in2 + F.upsample(
-            out3, scale_factor=2, mode="nearest", align_mode=1)  # 1/4
-
-        p5 = self.p5_conv(in5)
-        p4 = self.p4_conv(out4)
-        p3 = self.p3_conv(out3)
-        p2 = self.p2_conv(out2)
-
-        # 特征上采样
-        p5 = F.upsample(p5, scale_factor=8, mode="nearest", align_mode=1)
-        p4 = F.upsample(p4, scale_factor=4, mode="nearest", align_mode=1)
-        p3 = F.upsample(p3, scale_factor=2, mode="nearest", align_mode=1)
-
-        fuse = paddle.concat([p5, p4, p3, p2], axis=1)
-        return fuse

pyxlpr/ppocr/modeling/necks/east_fpn.py

@@ -1,188 +0,0 @@
-# copyright (c) 2019 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 paddle.nn.functional as F
-from paddle import ParamAttr
-
-
-class ConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 padding,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(ConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.conv = nn.Conv2D(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '_weights'),
-            bias_attr=False)
-
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name="bn_" + name + "_scale"),
-            bias_attr=ParamAttr(name="bn_" + name + "_offset"),
-            moving_mean_name="bn_" + name + "_mean",
-            moving_variance_name="bn_" + name + "_variance")
-
-    def forward(self, x):
-        x = self.conv(x)
-        x = self.bn(x)
-        return x
-
-
-class DeConvBNLayer(nn.Layer):
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size,
-                 stride,
-                 padding,
-                 groups=1,
-                 if_act=True,
-                 act=None,
-                 name=None):
-        super(DeConvBNLayer, self).__init__()
-        self.if_act = if_act
-        self.act = act
-        self.deconv = nn.Conv2DTranspose(
-            in_channels=in_channels,
-            out_channels=out_channels,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            groups=groups,
-            weight_attr=ParamAttr(name=name + '_weights'),
-            bias_attr=False)
-        self.bn = nn.BatchNorm(
-            num_channels=out_channels,
-            act=act,
-            param_attr=ParamAttr(name="bn_" + name + "_scale"),
-            bias_attr=ParamAttr(name="bn_" + name + "_offset"),
-            moving_mean_name="bn_" + name + "_mean",
-            moving_variance_name="bn_" + name + "_variance")
-
-    def forward(self, x):
-        x = self.deconv(x)
-        x = self.bn(x)
-        return x
-
-
-class EASTFPN(nn.Layer):
-    def __init__(self, in_channels, model_name, **kwargs):
-        super(EASTFPN, self).__init__()
-        self.model_name = model_name
-        if self.model_name == "large":
-            self.out_channels = 128
-        else:
-            self.out_channels = 64
-        self.in_channels = in_channels[::-1]
-        self.h1_conv = ConvBNLayer(
-            in_channels=self.out_channels+self.in_channels[1],
-            out_channels=self.out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_h_1")
-        self.h2_conv = ConvBNLayer(
-            in_channels=self.out_channels+self.in_channels[2],
-            out_channels=self.out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_h_2")
-        self.h3_conv = ConvBNLayer(
-            in_channels=self.out_channels+self.in_channels[3],
-            out_channels=self.out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_h_3")
-        self.g0_deconv = DeConvBNLayer(
-            in_channels=self.in_channels[0],
-            out_channels=self.out_channels,
-            kernel_size=4,
-            stride=2,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_g_0")
-        self.g1_deconv = DeConvBNLayer(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels,
-            kernel_size=4,
-            stride=2,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_g_1")
-        self.g2_deconv = DeConvBNLayer(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels,
-            kernel_size=4,
-            stride=2,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_g_2")
-        self.g3_conv = ConvBNLayer(
-            in_channels=self.out_channels,
-            out_channels=self.out_channels,
-            kernel_size=3,
-            stride=1,
-            padding=1,
-            if_act=True,
-            act='relu',
-            name="unet_g_3")
-
-    def forward(self, x):
-        f = x[::-1]
-
-        h = f[0]
-        g = self.g0_deconv(h)
-        h = paddle.concat([g, f[1]], axis=1)
-        h = self.h1_conv(h)
-        g = self.g1_deconv(h)
-        h = paddle.concat([g, f[2]], axis=1)
-        h = self.h2_conv(h)
-        g = self.g2_deconv(h)
-        h = paddle.concat([g, f[3]], axis=1)
-        h = self.h3_conv(h)
-        g = self.g3_conv(h)
-
-        return g

pyxlpr/ppocr/modeling/necks/fpn.py

@@ -1,138 +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.
-"""
-This code is refer from:
-https://github.com/whai362/PSENet/blob/python3/models/neck/fpn.py
-"""
-
-import paddle.nn as nn
-import paddle
-import math
-import paddle.nn.functional as F
-
-
-class Conv_BN_ReLU(nn.Layer):
-    def __init__(self,
-                 in_planes,
-                 out_planes,
-                 kernel_size=1,
-                 stride=1,
-                 padding=0):
-        super(Conv_BN_ReLU, self).__init__()
-        self.conv = nn.Conv2D(
-            in_planes,
-            out_planes,
-            kernel_size=kernel_size,
-            stride=stride,
-            padding=padding,
-            bias_attr=False)
-        self.bn = nn.BatchNorm2D(out_planes, momentum=0.1)
-        self.relu = nn.ReLU()
-
-        for m in self.sublayers():
-            if isinstance(m, nn.Conv2D):
-                n = m._kernel_size[0] * m._kernel_size[1] * m._out_channels
-                m.weight = paddle.create_parameter(
-                    shape=m.weight.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Normal(
-                        0, math.sqrt(2. / n)))
-            elif isinstance(m, nn.BatchNorm2D):
-                m.weight = paddle.create_parameter(
-                    shape=m.weight.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Constant(1.0))
-                m.bias = paddle.create_parameter(
-                    shape=m.bias.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Constant(0.0))
-
-    def forward(self, x):
-        return self.relu(self.bn(self.conv(x)))
-
-
-class FPN(nn.Layer):
-    def __init__(self, in_channels, out_channels):
-        super(FPN, self).__init__()
-
-        # Top layer
-        self.toplayer_ = Conv_BN_ReLU(
-            in_channels[3], out_channels, kernel_size=1, stride=1, padding=0)
-        # Lateral layers
-        self.latlayer1_ = Conv_BN_ReLU(
-            in_channels[2], out_channels, kernel_size=1, stride=1, padding=0)
-
-        self.latlayer2_ = Conv_BN_ReLU(
-            in_channels[1], out_channels, kernel_size=1, stride=1, padding=0)
-
-        self.latlayer3_ = Conv_BN_ReLU(
-            in_channels[0], out_channels, kernel_size=1, stride=1, padding=0)
-
-        # Smooth layers
-        self.smooth1_ = Conv_BN_ReLU(
-            out_channels, out_channels, kernel_size=3, stride=1, padding=1)
-
-        self.smooth2_ = Conv_BN_ReLU(
-            out_channels, out_channels, kernel_size=3, stride=1, padding=1)
-
-        self.smooth3_ = Conv_BN_ReLU(
-            out_channels, out_channels, kernel_size=3, stride=1, padding=1)
-
-        self.out_channels = out_channels * 4
-        for m in self.sublayers():
-            if isinstance(m, nn.Conv2D):
-                n = m._kernel_size[0] * m._kernel_size[1] * m._out_channels
-                m.weight = paddle.create_parameter(
-                    shape=m.weight.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Normal(
-                        0, math.sqrt(2. / n)))
-            elif isinstance(m, nn.BatchNorm2D):
-                m.weight = paddle.create_parameter(
-                    shape=m.weight.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Constant(1.0))
-                m.bias = paddle.create_parameter(
-                    shape=m.bias.shape,
-                    dtype='float32',
-                    default_initializer=paddle.nn.initializer.Constant(0.0))
-
-    def _upsample(self, x, scale=1):
-        return F.upsample(x, scale_factor=scale, mode='bilinear')
-
-    def _upsample_add(self, x, y, scale=1):
-        return F.upsample(x, scale_factor=scale, mode='bilinear') + y
-
-    def forward(self, x):
-        f2, f3, f4, f5 = x
-        p5 = self.toplayer_(f5)
-
-        f4 = self.latlayer1_(f4)
-        p4 = self._upsample_add(p5, f4, 2)
-        p4 = self.smooth1_(p4)
-
-        f3 = self.latlayer2_(f3)
-        p3 = self._upsample_add(p4, f3, 2)
-        p3 = self.smooth2_(p3)
-
-        f2 = self.latlayer3_(f2)
-        p2 = self._upsample_add(p3, f2, 2)
-        p2 = self.smooth3_(p2)
-
-        p3 = self._upsample(p3, 2)
-        p4 = self._upsample(p4, 4)
-        p5 = self._upsample(p5, 8)
-
-        fuse = paddle.concat([p2, p3, p4, p5], axis=1)
-        return fuse